docusign_esign.apis.accounts_api
DocuSign REST API
The DocuSign REST API provides you with a powerful, convenient, and simple Web services API for interacting with DocuSign. # noqa: E501
OpenAPI spec version: v2.1 Contact: devcenter@docusign.com Generated by: https://github.com/swagger-api/swagger-codegen.git
1# coding: utf-8 2 3""" 4 DocuSign REST API 5 6 The DocuSign REST API provides you with a powerful, convenient, and simple Web services API for interacting with DocuSign. # noqa: E501 7 8 OpenAPI spec version: v2.1 9 Contact: devcenter@docusign.com 10 Generated by: https://github.com/swagger-api/swagger-codegen.git 11""" 12 13 14from __future__ import absolute_import 15 16import sys 17import os 18import re 19 20# python 2 and python 3 compatibility library 21from six import iteritems 22 23from ..client.configuration import Configuration 24from ..client.api_client import ApiClient 25 26 27class 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 :return: None 827 If the method is called asynchronously, 828 returns the request thread. 829 """ 830 kwargs['_return_http_data_only'] = True 831 if kwargs.get('callback'): 832 return self.delete_with_http_info(account_id, **kwargs) 833 else: 834 (data) = self.delete_with_http_info(account_id, **kwargs) 835 return data 836 837 def delete_with_http_info(self, account_id, **kwargs): 838 """ 839 Deletes the specified account. 840 This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign. 841 This method makes a synchronous HTTP request by default. To make an 842 asynchronous HTTP request, please define a `callback` function 843 to be invoked when receiving the response. 844 >>> def callback_function(response): 845 >>> pprint(response) 846 >>> 847 >>> thread = api.delete_with_http_info(account_id, callback=callback_function) 848 849 :param callback function: The callback function 850 for asynchronous request. (optional) 851 :param str account_id: The external account number (int) or account ID Guid. (required) 852 :return: None 853 If the method is called asynchronously, 854 returns the request thread. 855 """ 856 857 all_params = ['account_id'] 858 all_params.append('callback') 859 all_params.append('_return_http_data_only') 860 all_params.append('_preload_content') 861 all_params.append('_request_timeout') 862 863 params = locals() 864 for key, val in iteritems(params['kwargs']): 865 if key not in all_params: 866 raise TypeError( 867 "Got an unexpected keyword argument '%s'" 868 " to method delete" % key 869 ) 870 params[key] = val 871 del params['kwargs'] 872 # verify the required parameter 'account_id' is set 873 if ('account_id' not in params) or (params['account_id'] is None): 874 raise ValueError("Missing the required parameter `account_id` when calling `delete`") 875 876 877 collection_formats = {} 878 879 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 880 path_params = {} 881 if 'account_id' in params: 882 path_params['accountId'] = params['account_id'] 883 884 query_params = {} 885 886 header_params = {} 887 888 form_params = [] 889 local_var_files = {} 890 891 body_params = None 892 # HTTP header `Accept` 893 header_params['Accept'] = self.api_client.\ 894 select_header_accept(['application/json']) 895 896 # Authentication setting 897 auth_settings = [] 898 899 return self.api_client.call_api(resource_path, 'DELETE', 900 path_params, 901 query_params, 902 header_params, 903 body=body_params, 904 post_params=form_params, 905 files=local_var_files, 906 response_type=None, 907 auth_settings=auth_settings, 908 callback=params.get('callback'), 909 _return_http_data_only=params.get('_return_http_data_only'), 910 _preload_content=params.get('_preload_content', True), 911 _request_timeout=params.get('_request_timeout'), 912 collection_formats=collection_formats) 913 914 def delete_account_signature(self, account_id, signature_id, **kwargs): 915 """ 916 Close the specified signature by Id. 917 918 This method makes a synchronous HTTP request by default. To make an 919 asynchronous HTTP request, please define a `callback` function 920 to be invoked when receiving the response. 921 >>> def callback_function(response): 922 >>> pprint(response) 923 >>> 924 >>> thread = api.delete_account_signature(account_id, signature_id, callback=callback_function) 925 926 :param callback function: The callback function 927 for asynchronous request. (optional) 928 :param str account_id: The external account number (int) or account ID Guid. (required) 929 :param str signature_id: The ID of the signature being accessed. (required) 930 :return: None 931 If the method is called asynchronously, 932 returns the request thread. 933 """ 934 kwargs['_return_http_data_only'] = True 935 if kwargs.get('callback'): 936 return self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 937 else: 938 (data) = self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 939 return data 940 941 def delete_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 942 """ 943 Close the specified signature by Id. 944 945 This method makes a synchronous HTTP request by default. To make an 946 asynchronous HTTP request, please define a `callback` function 947 to be invoked when receiving the response. 948 >>> def callback_function(response): 949 >>> pprint(response) 950 >>> 951 >>> thread = api.delete_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 952 953 :param callback function: The callback function 954 for asynchronous request. (optional) 955 :param str account_id: The external account number (int) or account ID Guid. (required) 956 :param str signature_id: The ID of the signature being accessed. (required) 957 :return: None 958 If the method is called asynchronously, 959 returns the request thread. 960 """ 961 962 all_params = ['account_id', 'signature_id'] 963 all_params.append('callback') 964 all_params.append('_return_http_data_only') 965 all_params.append('_preload_content') 966 all_params.append('_request_timeout') 967 968 params = locals() 969 for key, val in iteritems(params['kwargs']): 970 if key not in all_params: 971 raise TypeError( 972 "Got an unexpected keyword argument '%s'" 973 " to method delete_account_signature" % key 974 ) 975 params[key] = val 976 del params['kwargs'] 977 # verify the required parameter 'account_id' is set 978 if ('account_id' not in params) or (params['account_id'] is None): 979 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature`") 980 # verify the required parameter 'signature_id' is set 981 if ('signature_id' not in params) or (params['signature_id'] is None): 982 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature`") 983 984 985 collection_formats = {} 986 987 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 988 path_params = {} 989 if 'account_id' in params: 990 path_params['accountId'] = params['account_id'] 991 if 'signature_id' in params: 992 path_params['signatureId'] = params['signature_id'] 993 994 query_params = {} 995 996 header_params = {} 997 998 form_params = [] 999 local_var_files = {} 1000 1001 body_params = None 1002 # HTTP header `Accept` 1003 header_params['Accept'] = self.api_client.\ 1004 select_header_accept(['application/json']) 1005 1006 # Authentication setting 1007 auth_settings = [] 1008 1009 return self.api_client.call_api(resource_path, 'DELETE', 1010 path_params, 1011 query_params, 1012 header_params, 1013 body=body_params, 1014 post_params=form_params, 1015 files=local_var_files, 1016 response_type=None, 1017 auth_settings=auth_settings, 1018 callback=params.get('callback'), 1019 _return_http_data_only=params.get('_return_http_data_only'), 1020 _preload_content=params.get('_preload_content', True), 1021 _request_timeout=params.get('_request_timeout'), 1022 collection_formats=collection_formats) 1023 1024 def delete_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 1025 """ 1026 Deletes a signature, initials, or stamps image. 1027 1028 This method makes a synchronous HTTP request by default. To make an 1029 asynchronous HTTP request, please define a `callback` function 1030 to be invoked when receiving the response. 1031 >>> def callback_function(response): 1032 >>> pprint(response) 1033 >>> 1034 >>> thread = api.delete_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 1035 1036 :param callback function: The callback function 1037 for asynchronous request. (optional) 1038 :param str account_id: The external account number (int) or account ID Guid. (required) 1039 :param str image_type: One of **signature_image** or **initials_image**. (required) 1040 :param str signature_id: The ID of the signature being accessed. (required) 1041 :return: AccountSignature 1042 If the method is called asynchronously, 1043 returns the request thread. 1044 """ 1045 kwargs['_return_http_data_only'] = True 1046 if kwargs.get('callback'): 1047 return self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 1048 else: 1049 (data) = self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 1050 return data 1051 1052 def delete_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 1053 """ 1054 Deletes a signature, initials, or stamps image. 1055 1056 This method makes a synchronous HTTP request by default. To make an 1057 asynchronous HTTP request, please define a `callback` function 1058 to be invoked when receiving the response. 1059 >>> def callback_function(response): 1060 >>> pprint(response) 1061 >>> 1062 >>> thread = api.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 1063 1064 :param callback function: The callback function 1065 for asynchronous request. (optional) 1066 :param str account_id: The external account number (int) or account ID Guid. (required) 1067 :param str image_type: One of **signature_image** or **initials_image**. (required) 1068 :param str signature_id: The ID of the signature being accessed. (required) 1069 :return: AccountSignature 1070 If the method is called asynchronously, 1071 returns the request thread. 1072 """ 1073 1074 all_params = ['account_id', 'image_type', 'signature_id'] 1075 all_params.append('callback') 1076 all_params.append('_return_http_data_only') 1077 all_params.append('_preload_content') 1078 all_params.append('_request_timeout') 1079 1080 params = locals() 1081 for key, val in iteritems(params['kwargs']): 1082 if key not in all_params: 1083 raise TypeError( 1084 "Got an unexpected keyword argument '%s'" 1085 " to method delete_account_signature_image" % key 1086 ) 1087 params[key] = val 1088 del params['kwargs'] 1089 # verify the required parameter 'account_id' is set 1090 if ('account_id' not in params) or (params['account_id'] is None): 1091 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature_image`") 1092 # verify the required parameter 'image_type' is set 1093 if ('image_type' not in params) or (params['image_type'] is None): 1094 raise ValueError("Missing the required parameter `image_type` when calling `delete_account_signature_image`") 1095 # verify the required parameter 'signature_id' is set 1096 if ('signature_id' not in params) or (params['signature_id'] is None): 1097 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature_image`") 1098 1099 1100 collection_formats = {} 1101 1102 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 1103 path_params = {} 1104 if 'account_id' in params: 1105 path_params['accountId'] = params['account_id'] 1106 if 'image_type' in params: 1107 path_params['imageType'] = params['image_type'] 1108 if 'signature_id' in params: 1109 path_params['signatureId'] = params['signature_id'] 1110 1111 query_params = {} 1112 1113 header_params = {} 1114 1115 form_params = [] 1116 local_var_files = {} 1117 1118 body_params = None 1119 # HTTP header `Accept` 1120 header_params['Accept'] = self.api_client.\ 1121 select_header_accept(['application/json']) 1122 1123 # Authentication setting 1124 auth_settings = [] 1125 1126 return self.api_client.call_api(resource_path, 'DELETE', 1127 path_params, 1128 query_params, 1129 header_params, 1130 body=body_params, 1131 post_params=form_params, 1132 files=local_var_files, 1133 response_type='AccountSignature', 1134 auth_settings=auth_settings, 1135 callback=params.get('callback'), 1136 _return_http_data_only=params.get('_return_http_data_only'), 1137 _preload_content=params.get('_preload_content', True), 1138 _request_timeout=params.get('_request_timeout'), 1139 collection_formats=collection_formats) 1140 1141 def delete_brand(self, account_id, brand_id, **kwargs): 1142 """ 1143 Removes a brand. 1144 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**). 1145 This method makes a synchronous HTTP request by default. To make an 1146 asynchronous HTTP request, please define a `callback` function 1147 to be invoked when receiving the response. 1148 >>> def callback_function(response): 1149 >>> pprint(response) 1150 >>> 1151 >>> thread = api.delete_brand(account_id, brand_id, callback=callback_function) 1152 1153 :param callback function: The callback function 1154 for asynchronous request. (optional) 1155 :param str account_id: The external account number (int) or account ID Guid. (required) 1156 :param str brand_id: The unique identifier of a brand. (required) 1157 :return: None 1158 If the method is called asynchronously, 1159 returns the request thread. 1160 """ 1161 kwargs['_return_http_data_only'] = True 1162 if kwargs.get('callback'): 1163 return self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 1164 else: 1165 (data) = self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 1166 return data 1167 1168 def delete_brand_with_http_info(self, account_id, brand_id, **kwargs): 1169 """ 1170 Removes a brand. 1171 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**). 1172 This method makes a synchronous HTTP request by default. To make an 1173 asynchronous HTTP request, please define a `callback` function 1174 to be invoked when receiving the response. 1175 >>> def callback_function(response): 1176 >>> pprint(response) 1177 >>> 1178 >>> thread = api.delete_brand_with_http_info(account_id, brand_id, callback=callback_function) 1179 1180 :param callback function: The callback function 1181 for asynchronous request. (optional) 1182 :param str account_id: The external account number (int) or account ID Guid. (required) 1183 :param str brand_id: The unique identifier of a brand. (required) 1184 :return: None 1185 If the method is called asynchronously, 1186 returns the request thread. 1187 """ 1188 1189 all_params = ['account_id', 'brand_id'] 1190 all_params.append('callback') 1191 all_params.append('_return_http_data_only') 1192 all_params.append('_preload_content') 1193 all_params.append('_request_timeout') 1194 1195 params = locals() 1196 for key, val in iteritems(params['kwargs']): 1197 if key not in all_params: 1198 raise TypeError( 1199 "Got an unexpected keyword argument '%s'" 1200 " to method delete_brand" % key 1201 ) 1202 params[key] = val 1203 del params['kwargs'] 1204 # verify the required parameter 'account_id' is set 1205 if ('account_id' not in params) or (params['account_id'] is None): 1206 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand`") 1207 # verify the required parameter 'brand_id' is set 1208 if ('brand_id' not in params) or (params['brand_id'] is None): 1209 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand`") 1210 1211 1212 collection_formats = {} 1213 1214 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 1215 path_params = {} 1216 if 'account_id' in params: 1217 path_params['accountId'] = params['account_id'] 1218 if 'brand_id' in params: 1219 path_params['brandId'] = params['brand_id'] 1220 1221 query_params = {} 1222 1223 header_params = {} 1224 1225 form_params = [] 1226 local_var_files = {} 1227 1228 body_params = None 1229 # HTTP header `Accept` 1230 header_params['Accept'] = self.api_client.\ 1231 select_header_accept(['application/json']) 1232 1233 # Authentication setting 1234 auth_settings = [] 1235 1236 return self.api_client.call_api(resource_path, 'DELETE', 1237 path_params, 1238 query_params, 1239 header_params, 1240 body=body_params, 1241 post_params=form_params, 1242 files=local_var_files, 1243 response_type=None, 1244 auth_settings=auth_settings, 1245 callback=params.get('callback'), 1246 _return_http_data_only=params.get('_return_http_data_only'), 1247 _preload_content=params.get('_preload_content', True), 1248 _request_timeout=params.get('_request_timeout'), 1249 collection_formats=collection_formats) 1250 1251 def delete_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 1252 """ 1253 Delete one branding logo. 1254 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**). 1255 This method makes a synchronous HTTP request by default. To make an 1256 asynchronous HTTP request, please define a `callback` function 1257 to be invoked when receiving the response. 1258 >>> def callback_function(response): 1259 >>> pprint(response) 1260 >>> 1261 >>> thread = api.delete_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 1262 1263 :param callback function: The callback function 1264 for asynchronous request. (optional) 1265 :param str account_id: The external account number (int) or account ID Guid. (required) 1266 :param str brand_id: The unique identifier of a brand. (required) 1267 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1268 :return: None 1269 If the method is called asynchronously, 1270 returns the request thread. 1271 """ 1272 kwargs['_return_http_data_only'] = True 1273 if kwargs.get('callback'): 1274 return self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1275 else: 1276 (data) = self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1277 return data 1278 1279 def delete_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 1280 """ 1281 Delete one branding logo. 1282 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**). 1283 This method makes a synchronous HTTP request by default. To make an 1284 asynchronous HTTP request, please define a `callback` function 1285 to be invoked when receiving the response. 1286 >>> def callback_function(response): 1287 >>> pprint(response) 1288 >>> 1289 >>> thread = api.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 1290 1291 :param callback function: The callback function 1292 for asynchronous request. (optional) 1293 :param str account_id: The external account number (int) or account ID Guid. (required) 1294 :param str brand_id: The unique identifier of a brand. (required) 1295 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1296 :return: None 1297 If the method is called asynchronously, 1298 returns the request thread. 1299 """ 1300 1301 all_params = ['account_id', 'brand_id', 'logo_type'] 1302 all_params.append('callback') 1303 all_params.append('_return_http_data_only') 1304 all_params.append('_preload_content') 1305 all_params.append('_request_timeout') 1306 1307 params = locals() 1308 for key, val in iteritems(params['kwargs']): 1309 if key not in all_params: 1310 raise TypeError( 1311 "Got an unexpected keyword argument '%s'" 1312 " to method delete_brand_logo_by_type" % key 1313 ) 1314 params[key] = val 1315 del params['kwargs'] 1316 # verify the required parameter 'account_id' is set 1317 if ('account_id' not in params) or (params['account_id'] is None): 1318 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand_logo_by_type`") 1319 # verify the required parameter 'brand_id' is set 1320 if ('brand_id' not in params) or (params['brand_id'] is None): 1321 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand_logo_by_type`") 1322 # verify the required parameter 'logo_type' is set 1323 if ('logo_type' not in params) or (params['logo_type'] is None): 1324 raise ValueError("Missing the required parameter `logo_type` when calling `delete_brand_logo_by_type`") 1325 1326 1327 collection_formats = {} 1328 1329 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 1330 path_params = {} 1331 if 'account_id' in params: 1332 path_params['accountId'] = params['account_id'] 1333 if 'brand_id' in params: 1334 path_params['brandId'] = params['brand_id'] 1335 if 'logo_type' in params: 1336 path_params['logoType'] = params['logo_type'] 1337 1338 query_params = {} 1339 1340 header_params = {} 1341 1342 form_params = [] 1343 local_var_files = {} 1344 1345 body_params = None 1346 # HTTP header `Accept` 1347 header_params['Accept'] = self.api_client.\ 1348 select_header_accept(['application/json']) 1349 1350 # Authentication setting 1351 auth_settings = [] 1352 1353 return self.api_client.call_api(resource_path, 'DELETE', 1354 path_params, 1355 query_params, 1356 header_params, 1357 body=body_params, 1358 post_params=form_params, 1359 files=local_var_files, 1360 response_type=None, 1361 auth_settings=auth_settings, 1362 callback=params.get('callback'), 1363 _return_http_data_only=params.get('_return_http_data_only'), 1364 _preload_content=params.get('_preload_content', True), 1365 _request_timeout=params.get('_request_timeout'), 1366 collection_formats=collection_formats) 1367 1368 def delete_brands(self, account_id, **kwargs): 1369 """ 1370 Deletes one or more brand profiles. 1371 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. 1372 This method makes a synchronous HTTP request by default. To make an 1373 asynchronous HTTP request, please define a `callback` function 1374 to be invoked when receiving the response. 1375 >>> def callback_function(response): 1376 >>> pprint(response) 1377 >>> 1378 >>> thread = api.delete_brands(account_id, callback=callback_function) 1379 1380 :param callback function: The callback function 1381 for asynchronous request. (optional) 1382 :param str account_id: The external account number (int) or account ID Guid. (required) 1383 :param BrandsRequest brands_request: 1384 :return: BrandsResponse 1385 If the method is called asynchronously, 1386 returns the request thread. 1387 """ 1388 kwargs['_return_http_data_only'] = True 1389 if kwargs.get('callback'): 1390 return self.delete_brands_with_http_info(account_id, **kwargs) 1391 else: 1392 (data) = self.delete_brands_with_http_info(account_id, **kwargs) 1393 return data 1394 1395 def delete_brands_with_http_info(self, account_id, **kwargs): 1396 """ 1397 Deletes one or more brand profiles. 1398 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. 1399 This method makes a synchronous HTTP request by default. To make an 1400 asynchronous HTTP request, please define a `callback` function 1401 to be invoked when receiving the response. 1402 >>> def callback_function(response): 1403 >>> pprint(response) 1404 >>> 1405 >>> thread = api.delete_brands_with_http_info(account_id, callback=callback_function) 1406 1407 :param callback function: The callback function 1408 for asynchronous request. (optional) 1409 :param str account_id: The external account number (int) or account ID Guid. (required) 1410 :param BrandsRequest brands_request: 1411 :return: BrandsResponse 1412 If the method is called asynchronously, 1413 returns the request thread. 1414 """ 1415 1416 all_params = ['account_id', 'brands_request'] 1417 all_params.append('callback') 1418 all_params.append('_return_http_data_only') 1419 all_params.append('_preload_content') 1420 all_params.append('_request_timeout') 1421 1422 params = locals() 1423 for key, val in iteritems(params['kwargs']): 1424 if key not in all_params: 1425 raise TypeError( 1426 "Got an unexpected keyword argument '%s'" 1427 " to method delete_brands" % key 1428 ) 1429 params[key] = val 1430 del params['kwargs'] 1431 # verify the required parameter 'account_id' is set 1432 if ('account_id' not in params) or (params['account_id'] is None): 1433 raise ValueError("Missing the required parameter `account_id` when calling `delete_brands`") 1434 1435 1436 collection_formats = {} 1437 1438 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 1439 path_params = {} 1440 if 'account_id' in params: 1441 path_params['accountId'] = params['account_id'] 1442 1443 query_params = {} 1444 1445 header_params = {} 1446 1447 form_params = [] 1448 local_var_files = {} 1449 1450 body_params = None 1451 if 'brands_request' in params: 1452 body_params = params['brands_request'] 1453 # HTTP header `Accept` 1454 header_params['Accept'] = self.api_client.\ 1455 select_header_accept(['application/json']) 1456 1457 # Authentication setting 1458 auth_settings = [] 1459 1460 return self.api_client.call_api(resource_path, 'DELETE', 1461 path_params, 1462 query_params, 1463 header_params, 1464 body=body_params, 1465 post_params=form_params, 1466 files=local_var_files, 1467 response_type='BrandsResponse', 1468 auth_settings=auth_settings, 1469 callback=params.get('callback'), 1470 _return_http_data_only=params.get('_return_http_data_only'), 1471 _preload_content=params.get('_preload_content', True), 1472 _request_timeout=params.get('_request_timeout'), 1473 collection_formats=collection_formats) 1474 1475 def delete_captive_recipient(self, account_id, recipient_part, **kwargs): 1476 """ 1477 Deletes the signature for one or more captive recipient records. 1478 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. 1479 This method makes a synchronous HTTP request by default. To make an 1480 asynchronous HTTP request, please define a `callback` function 1481 to be invoked when receiving the response. 1482 >>> def callback_function(response): 1483 >>> pprint(response) 1484 >>> 1485 >>> thread = api.delete_captive_recipient(account_id, recipient_part, callback=callback_function) 1486 1487 :param callback function: The callback function 1488 for asynchronous request. (optional) 1489 :param str account_id: The external account number (int) or account ID Guid. (required) 1490 :param str recipient_part: (required) 1491 :param CaptiveRecipientInformation captive_recipient_information: 1492 :return: CaptiveRecipientInformation 1493 If the method is called asynchronously, 1494 returns the request thread. 1495 """ 1496 kwargs['_return_http_data_only'] = True 1497 if kwargs.get('callback'): 1498 return self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1499 else: 1500 (data) = self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1501 return data 1502 1503 def delete_captive_recipient_with_http_info(self, account_id, recipient_part, **kwargs): 1504 """ 1505 Deletes the signature for one or more captive recipient records. 1506 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. 1507 This method makes a synchronous HTTP request by default. To make an 1508 asynchronous HTTP request, please define a `callback` function 1509 to be invoked when receiving the response. 1510 >>> def callback_function(response): 1511 >>> pprint(response) 1512 >>> 1513 >>> thread = api.delete_captive_recipient_with_http_info(account_id, recipient_part, callback=callback_function) 1514 1515 :param callback function: The callback function 1516 for asynchronous request. (optional) 1517 :param str account_id: The external account number (int) or account ID Guid. (required) 1518 :param str recipient_part: (required) 1519 :param CaptiveRecipientInformation captive_recipient_information: 1520 :return: CaptiveRecipientInformation 1521 If the method is called asynchronously, 1522 returns the request thread. 1523 """ 1524 1525 all_params = ['account_id', 'recipient_part', 'captive_recipient_information'] 1526 all_params.append('callback') 1527 all_params.append('_return_http_data_only') 1528 all_params.append('_preload_content') 1529 all_params.append('_request_timeout') 1530 1531 params = locals() 1532 for key, val in iteritems(params['kwargs']): 1533 if key not in all_params: 1534 raise TypeError( 1535 "Got an unexpected keyword argument '%s'" 1536 " to method delete_captive_recipient" % key 1537 ) 1538 params[key] = val 1539 del params['kwargs'] 1540 # verify the required parameter 'account_id' is set 1541 if ('account_id' not in params) or (params['account_id'] is None): 1542 raise ValueError("Missing the required parameter `account_id` when calling `delete_captive_recipient`") 1543 # verify the required parameter 'recipient_part' is set 1544 if ('recipient_part' not in params) or (params['recipient_part'] is None): 1545 raise ValueError("Missing the required parameter `recipient_part` when calling `delete_captive_recipient`") 1546 1547 1548 collection_formats = {} 1549 1550 resource_path = '/v2.1/accounts/{accountId}/captive_recipients/{recipientPart}'.replace('{format}', 'json') 1551 path_params = {} 1552 if 'account_id' in params: 1553 path_params['accountId'] = params['account_id'] 1554 if 'recipient_part' in params: 1555 path_params['recipientPart'] = params['recipient_part'] 1556 1557 query_params = {} 1558 1559 header_params = {} 1560 1561 form_params = [] 1562 local_var_files = {} 1563 1564 body_params = None 1565 if 'captive_recipient_information' in params: 1566 body_params = params['captive_recipient_information'] 1567 # HTTP header `Accept` 1568 header_params['Accept'] = self.api_client.\ 1569 select_header_accept(['application/json']) 1570 1571 # Authentication setting 1572 auth_settings = [] 1573 1574 return self.api_client.call_api(resource_path, 'DELETE', 1575 path_params, 1576 query_params, 1577 header_params, 1578 body=body_params, 1579 post_params=form_params, 1580 files=local_var_files, 1581 response_type='CaptiveRecipientInformation', 1582 auth_settings=auth_settings, 1583 callback=params.get('callback'), 1584 _return_http_data_only=params.get('_return_http_data_only'), 1585 _preload_content=params.get('_preload_content', True), 1586 _request_timeout=params.get('_request_timeout'), 1587 collection_formats=collection_formats) 1588 1589 def delete_custom_field(self, account_id, custom_field_id, **kwargs): 1590 """ 1591 Delete an existing account custom field. 1592 This method deletes an existing account custom field. 1593 This method makes a synchronous HTTP request by default. To make an 1594 asynchronous HTTP request, please define a `callback` function 1595 to be invoked when receiving the response. 1596 >>> def callback_function(response): 1597 >>> pprint(response) 1598 >>> 1599 >>> thread = api.delete_custom_field(account_id, custom_field_id, callback=callback_function) 1600 1601 :param callback function: The callback function 1602 for asynchronous request. (optional) 1603 :param str account_id: The external account number (int) or account ID Guid. (required) 1604 :param str custom_field_id: (required) 1605 :param str apply_to_templates: 1606 :return: None 1607 If the method is called asynchronously, 1608 returns the request thread. 1609 """ 1610 kwargs['_return_http_data_only'] = True 1611 if kwargs.get('callback'): 1612 return self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1613 else: 1614 (data) = self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1615 return data 1616 1617 def delete_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 1618 """ 1619 Delete an existing account custom field. 1620 This method deletes an existing account custom field. 1621 This method makes a synchronous HTTP request by default. To make an 1622 asynchronous HTTP request, please define a `callback` function 1623 to be invoked when receiving the response. 1624 >>> def callback_function(response): 1625 >>> pprint(response) 1626 >>> 1627 >>> thread = api.delete_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 1628 1629 :param callback function: The callback function 1630 for asynchronous request. (optional) 1631 :param str account_id: The external account number (int) or account ID Guid. (required) 1632 :param str custom_field_id: (required) 1633 :param str apply_to_templates: 1634 :return: None 1635 If the method is called asynchronously, 1636 returns the request thread. 1637 """ 1638 1639 all_params = ['account_id', 'custom_field_id', 'apply_to_templates'] 1640 all_params.append('callback') 1641 all_params.append('_return_http_data_only') 1642 all_params.append('_preload_content') 1643 all_params.append('_request_timeout') 1644 1645 params = locals() 1646 for key, val in iteritems(params['kwargs']): 1647 if key not in all_params: 1648 raise TypeError( 1649 "Got an unexpected keyword argument '%s'" 1650 " to method delete_custom_field" % key 1651 ) 1652 params[key] = val 1653 del params['kwargs'] 1654 # verify the required parameter 'account_id' is set 1655 if ('account_id' not in params) or (params['account_id'] is None): 1656 raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_field`") 1657 # verify the required parameter 'custom_field_id' is set 1658 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 1659 raise ValueError("Missing the required parameter `custom_field_id` when calling `delete_custom_field`") 1660 1661 1662 collection_formats = {} 1663 1664 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 1665 path_params = {} 1666 if 'account_id' in params: 1667 path_params['accountId'] = params['account_id'] 1668 if 'custom_field_id' in params: 1669 path_params['customFieldId'] = params['custom_field_id'] 1670 1671 query_params = {} 1672 if 'apply_to_templates' in params: 1673 query_params['apply_to_templates'] = params['apply_to_templates'] 1674 1675 header_params = {} 1676 1677 form_params = [] 1678 local_var_files = {} 1679 1680 body_params = None 1681 # HTTP header `Accept` 1682 header_params['Accept'] = self.api_client.\ 1683 select_header_accept(['application/json']) 1684 1685 # Authentication setting 1686 auth_settings = [] 1687 1688 return self.api_client.call_api(resource_path, 'DELETE', 1689 path_params, 1690 query_params, 1691 header_params, 1692 body=body_params, 1693 post_params=form_params, 1694 files=local_var_files, 1695 response_type=None, 1696 auth_settings=auth_settings, 1697 callback=params.get('callback'), 1698 _return_http_data_only=params.get('_return_http_data_only'), 1699 _preload_content=params.get('_preload_content', True), 1700 _request_timeout=params.get('_request_timeout'), 1701 collection_formats=collection_formats) 1702 1703 def delete_e_note_configuration(self, account_id, **kwargs): 1704 """ 1705 Deletes configuration information for the eNote eOriginal integration. 1706 1707 This method makes a synchronous HTTP request by default. To make an 1708 asynchronous HTTP request, please define a `callback` function 1709 to be invoked when receiving the response. 1710 >>> def callback_function(response): 1711 >>> pprint(response) 1712 >>> 1713 >>> thread = api.delete_e_note_configuration(account_id, callback=callback_function) 1714 1715 :param callback function: The callback function 1716 for asynchronous request. (optional) 1717 :param str account_id: The external account number (int) or account ID Guid. (required) 1718 :return: None 1719 If the method is called asynchronously, 1720 returns the request thread. 1721 """ 1722 kwargs['_return_http_data_only'] = True 1723 if kwargs.get('callback'): 1724 return self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1725 else: 1726 (data) = self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1727 return data 1728 1729 def delete_e_note_configuration_with_http_info(self, account_id, **kwargs): 1730 """ 1731 Deletes configuration information for the eNote eOriginal integration. 1732 1733 This method makes a synchronous HTTP request by default. To make an 1734 asynchronous HTTP request, please define a `callback` function 1735 to be invoked when receiving the response. 1736 >>> def callback_function(response): 1737 >>> pprint(response) 1738 >>> 1739 >>> thread = api.delete_e_note_configuration_with_http_info(account_id, callback=callback_function) 1740 1741 :param callback function: The callback function 1742 for asynchronous request. (optional) 1743 :param str account_id: The external account number (int) or account ID Guid. (required) 1744 :return: None 1745 If the method is called asynchronously, 1746 returns the request thread. 1747 """ 1748 1749 all_params = ['account_id'] 1750 all_params.append('callback') 1751 all_params.append('_return_http_data_only') 1752 all_params.append('_preload_content') 1753 all_params.append('_request_timeout') 1754 1755 params = locals() 1756 for key, val in iteritems(params['kwargs']): 1757 if key not in all_params: 1758 raise TypeError( 1759 "Got an unexpected keyword argument '%s'" 1760 " to method delete_e_note_configuration" % key 1761 ) 1762 params[key] = val 1763 del params['kwargs'] 1764 # verify the required parameter 'account_id' is set 1765 if ('account_id' not in params) or (params['account_id'] is None): 1766 raise ValueError("Missing the required parameter `account_id` when calling `delete_e_note_configuration`") 1767 1768 1769 collection_formats = {} 1770 1771 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 1772 path_params = {} 1773 if 'account_id' in params: 1774 path_params['accountId'] = params['account_id'] 1775 1776 query_params = {} 1777 1778 header_params = {} 1779 1780 form_params = [] 1781 local_var_files = {} 1782 1783 body_params = None 1784 # HTTP header `Accept` 1785 header_params['Accept'] = self.api_client.\ 1786 select_header_accept(['application/json']) 1787 1788 # Authentication setting 1789 auth_settings = [] 1790 1791 return self.api_client.call_api(resource_path, 'DELETE', 1792 path_params, 1793 query_params, 1794 header_params, 1795 body=body_params, 1796 post_params=form_params, 1797 files=local_var_files, 1798 response_type=None, 1799 auth_settings=auth_settings, 1800 callback=params.get('callback'), 1801 _return_http_data_only=params.get('_return_http_data_only'), 1802 _preload_content=params.get('_preload_content', True), 1803 _request_timeout=params.get('_request_timeout'), 1804 collection_formats=collection_formats) 1805 1806 def delete_permission_profile(self, account_id, permission_profile_id, **kwargs): 1807 """ 1808 Deletes a permissions profile within the specified account. 1809 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/) 1810 This method makes a synchronous HTTP request by default. To make an 1811 asynchronous HTTP request, please define a `callback` function 1812 to be invoked when receiving the response. 1813 >>> def callback_function(response): 1814 >>> pprint(response) 1815 >>> 1816 >>> thread = api.delete_permission_profile(account_id, permission_profile_id, callback=callback_function) 1817 1818 :param callback function: The callback function 1819 for asynchronous request. (optional) 1820 :param str account_id: The external account number (int) or account ID Guid. (required) 1821 :param str permission_profile_id: (required) 1822 :param str move_users_to: 1823 :return: None 1824 If the method is called asynchronously, 1825 returns the request thread. 1826 """ 1827 kwargs['_return_http_data_only'] = True 1828 if kwargs.get('callback'): 1829 return self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1830 else: 1831 (data) = self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1832 return data 1833 1834 def delete_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 1835 """ 1836 Deletes a permissions profile within the specified account. 1837 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/) 1838 This method makes a synchronous HTTP request by default. To make an 1839 asynchronous HTTP request, please define a `callback` function 1840 to be invoked when receiving the response. 1841 >>> def callback_function(response): 1842 >>> pprint(response) 1843 >>> 1844 >>> thread = api.delete_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 1845 1846 :param callback function: The callback function 1847 for asynchronous request. (optional) 1848 :param str account_id: The external account number (int) or account ID Guid. (required) 1849 :param str permission_profile_id: (required) 1850 :param str move_users_to: 1851 :return: None 1852 If the method is called asynchronously, 1853 returns the request thread. 1854 """ 1855 1856 all_params = ['account_id', 'permission_profile_id', 'move_users_to'] 1857 all_params.append('callback') 1858 all_params.append('_return_http_data_only') 1859 all_params.append('_preload_content') 1860 all_params.append('_request_timeout') 1861 1862 params = locals() 1863 for key, val in iteritems(params['kwargs']): 1864 if key not in all_params: 1865 raise TypeError( 1866 "Got an unexpected keyword argument '%s'" 1867 " to method delete_permission_profile" % key 1868 ) 1869 params[key] = val 1870 del params['kwargs'] 1871 # verify the required parameter 'account_id' is set 1872 if ('account_id' not in params) or (params['account_id'] is None): 1873 raise ValueError("Missing the required parameter `account_id` when calling `delete_permission_profile`") 1874 # verify the required parameter 'permission_profile_id' is set 1875 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 1876 raise ValueError("Missing the required parameter `permission_profile_id` when calling `delete_permission_profile`") 1877 1878 1879 collection_formats = {} 1880 1881 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 1882 path_params = {} 1883 if 'account_id' in params: 1884 path_params['accountId'] = params['account_id'] 1885 if 'permission_profile_id' in params: 1886 path_params['permissionProfileId'] = params['permission_profile_id'] 1887 1888 query_params = {} 1889 if 'move_users_to' in params: 1890 query_params['move_users_to'] = params['move_users_to'] 1891 1892 header_params = {} 1893 1894 form_params = [] 1895 local_var_files = {} 1896 1897 body_params = None 1898 # HTTP header `Accept` 1899 header_params['Accept'] = self.api_client.\ 1900 select_header_accept(['application/json']) 1901 1902 # Authentication setting 1903 auth_settings = [] 1904 1905 return self.api_client.call_api(resource_path, 'DELETE', 1906 path_params, 1907 query_params, 1908 header_params, 1909 body=body_params, 1910 post_params=form_params, 1911 files=local_var_files, 1912 response_type=None, 1913 auth_settings=auth_settings, 1914 callback=params.get('callback'), 1915 _return_http_data_only=params.get('_return_http_data_only'), 1916 _preload_content=params.get('_preload_content', True), 1917 _request_timeout=params.get('_request_timeout'), 1918 collection_formats=collection_formats) 1919 1920 def delete_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 1921 """ 1922 Deletes the user authorization 1923 This method makes a synchronous HTTP request by default. To make an 1924 asynchronous HTTP request, please define a `callback` function 1925 to be invoked when receiving the response. 1926 >>> def callback_function(response): 1927 >>> pprint(response) 1928 >>> 1929 >>> thread = api.delete_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 1930 1931 :param callback function: The callback function 1932 for asynchronous request. (optional) 1933 :param str account_id: The external account number (int) or account ID Guid. (required) 1934 :param str authorization_id: (required) 1935 :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) 1936 :return: None 1937 If the method is called asynchronously, 1938 returns the request thread. 1939 """ 1940 kwargs['_return_http_data_only'] = True 1941 if kwargs.get('callback'): 1942 return self.delete_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 1943 else: 1944 (data) = self.delete_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 1945 return data 1946 1947 def delete_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 1948 """ 1949 Deletes the user authorization 1950 This method makes a synchronous HTTP request by default. To make an 1951 asynchronous HTTP request, please define a `callback` function 1952 to be invoked when receiving the response. 1953 >>> def callback_function(response): 1954 >>> pprint(response) 1955 >>> 1956 >>> thread = api.delete_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 1957 1958 :param callback function: The callback function 1959 for asynchronous request. (optional) 1960 :param str account_id: The external account number (int) or account ID Guid. (required) 1961 :param str authorization_id: (required) 1962 :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) 1963 :return: None 1964 If the method is called asynchronously, 1965 returns the request thread. 1966 """ 1967 1968 all_params = ['account_id', 'authorization_id', 'user_id'] 1969 all_params.append('callback') 1970 all_params.append('_return_http_data_only') 1971 all_params.append('_preload_content') 1972 all_params.append('_request_timeout') 1973 1974 params = locals() 1975 for key, val in iteritems(params['kwargs']): 1976 if key not in all_params: 1977 raise TypeError( 1978 "Got an unexpected keyword argument '%s'" 1979 " to method delete_user_authorization" % key 1980 ) 1981 params[key] = val 1982 del params['kwargs'] 1983 # verify the required parameter 'account_id' is set 1984 if ('account_id' not in params) or (params['account_id'] is None): 1985 raise ValueError("Missing the required parameter `account_id` when calling `delete_user_authorization`") 1986 # verify the required parameter 'authorization_id' is set 1987 if ('authorization_id' not in params) or (params['authorization_id'] is None): 1988 raise ValueError("Missing the required parameter `authorization_id` when calling `delete_user_authorization`") 1989 # verify the required parameter 'user_id' is set 1990 if ('user_id' not in params) or (params['user_id'] is None): 1991 raise ValueError("Missing the required parameter `user_id` when calling `delete_user_authorization`") 1992 1993 1994 collection_formats = {} 1995 1996 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 1997 path_params = {} 1998 if 'account_id' in params: 1999 path_params['accountId'] = params['account_id'] 2000 if 'authorization_id' in params: 2001 path_params['authorizationId'] = params['authorization_id'] 2002 if 'user_id' in params: 2003 path_params['userId'] = params['user_id'] 2004 2005 query_params = {} 2006 2007 header_params = {} 2008 2009 form_params = [] 2010 local_var_files = {} 2011 2012 body_params = None 2013 # HTTP header `Accept` 2014 header_params['Accept'] = self.api_client.\ 2015 select_header_accept(['application/json']) 2016 2017 # Authentication setting 2018 auth_settings = [] 2019 2020 return self.api_client.call_api(resource_path, 'DELETE', 2021 path_params, 2022 query_params, 2023 header_params, 2024 body=body_params, 2025 post_params=form_params, 2026 files=local_var_files, 2027 response_type=None, 2028 auth_settings=auth_settings, 2029 callback=params.get('callback'), 2030 _return_http_data_only=params.get('_return_http_data_only'), 2031 _preload_content=params.get('_preload_content', True), 2032 _request_timeout=params.get('_request_timeout'), 2033 collection_formats=collection_formats) 2034 2035 def delete_user_authorizations(self, account_id, user_id, **kwargs): 2036 """ 2037 Creates ot updates user authorizations 2038 This method makes a synchronous HTTP request by default. To make an 2039 asynchronous HTTP request, please define a `callback` function 2040 to be invoked when receiving the response. 2041 >>> def callback_function(response): 2042 >>> pprint(response) 2043 >>> 2044 >>> thread = api.delete_user_authorizations(account_id, user_id, callback=callback_function) 2045 2046 :param callback function: The callback function 2047 for asynchronous request. (optional) 2048 :param str account_id: The external account number (int) or account ID Guid. (required) 2049 :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) 2050 :param UserAuthorizationsDeleteRequest user_authorizations_delete_request: 2051 :return: UserAuthorizationsDeleteResponse 2052 If the method is called asynchronously, 2053 returns the request thread. 2054 """ 2055 kwargs['_return_http_data_only'] = True 2056 if kwargs.get('callback'): 2057 return self.delete_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2058 else: 2059 (data) = self.delete_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2060 return data 2061 2062 def delete_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 2063 """ 2064 Creates ot updates user authorizations 2065 This method makes a synchronous HTTP request by default. To make an 2066 asynchronous HTTP request, please define a `callback` function 2067 to be invoked when receiving the response. 2068 >>> def callback_function(response): 2069 >>> pprint(response) 2070 >>> 2071 >>> thread = api.delete_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 2072 2073 :param callback function: The callback function 2074 for asynchronous request. (optional) 2075 :param str account_id: The external account number (int) or account ID Guid. (required) 2076 :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) 2077 :param UserAuthorizationsDeleteRequest user_authorizations_delete_request: 2078 :return: UserAuthorizationsDeleteResponse 2079 If the method is called asynchronously, 2080 returns the request thread. 2081 """ 2082 2083 all_params = ['account_id', 'user_id', 'user_authorizations_delete_request'] 2084 all_params.append('callback') 2085 all_params.append('_return_http_data_only') 2086 all_params.append('_preload_content') 2087 all_params.append('_request_timeout') 2088 2089 params = locals() 2090 for key, val in iteritems(params['kwargs']): 2091 if key not in all_params: 2092 raise TypeError( 2093 "Got an unexpected keyword argument '%s'" 2094 " to method delete_user_authorizations" % key 2095 ) 2096 params[key] = val 2097 del params['kwargs'] 2098 # verify the required parameter 'account_id' is set 2099 if ('account_id' not in params) or (params['account_id'] is None): 2100 raise ValueError("Missing the required parameter `account_id` when calling `delete_user_authorizations`") 2101 # verify the required parameter 'user_id' is set 2102 if ('user_id' not in params) or (params['user_id'] is None): 2103 raise ValueError("Missing the required parameter `user_id` when calling `delete_user_authorizations`") 2104 2105 2106 collection_formats = {} 2107 2108 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations'.replace('{format}', 'json') 2109 path_params = {} 2110 if 'account_id' in params: 2111 path_params['accountId'] = params['account_id'] 2112 if 'user_id' in params: 2113 path_params['userId'] = params['user_id'] 2114 2115 query_params = {} 2116 2117 header_params = {} 2118 2119 form_params = [] 2120 local_var_files = {} 2121 2122 body_params = None 2123 if 'user_authorizations_delete_request' in params: 2124 body_params = params['user_authorizations_delete_request'] 2125 # HTTP header `Accept` 2126 header_params['Accept'] = self.api_client.\ 2127 select_header_accept(['application/json']) 2128 2129 # Authentication setting 2130 auth_settings = [] 2131 2132 return self.api_client.call_api(resource_path, 'DELETE', 2133 path_params, 2134 query_params, 2135 header_params, 2136 body=body_params, 2137 post_params=form_params, 2138 files=local_var_files, 2139 response_type='UserAuthorizationsDeleteResponse', 2140 auth_settings=auth_settings, 2141 callback=params.get('callback'), 2142 _return_http_data_only=params.get('_return_http_data_only'), 2143 _preload_content=params.get('_preload_content', True), 2144 _request_timeout=params.get('_request_timeout'), 2145 collection_formats=collection_formats) 2146 2147 def get_account_identity_verification(self, account_id, **kwargs): 2148 """ 2149 Get the list of identity verification options for an account 2150 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/) 2151 This method makes a synchronous HTTP request by default. To make an 2152 asynchronous HTTP request, please define a `callback` function 2153 to be invoked when receiving the response. 2154 >>> def callback_function(response): 2155 >>> pprint(response) 2156 >>> 2157 >>> thread = api.get_account_identity_verification(account_id, callback=callback_function) 2158 2159 :param callback function: The callback function 2160 for asynchronous request. (optional) 2161 :param str account_id: The external account number (int) or account ID Guid. (required) 2162 :return: AccountIdentityVerificationResponse 2163 If the method is called asynchronously, 2164 returns the request thread. 2165 """ 2166 kwargs['_return_http_data_only'] = True 2167 if kwargs.get('callback'): 2168 return self.get_account_identity_verification_with_http_info(account_id, **kwargs) 2169 else: 2170 (data) = self.get_account_identity_verification_with_http_info(account_id, **kwargs) 2171 return data 2172 2173 def get_account_identity_verification_with_http_info(self, account_id, **kwargs): 2174 """ 2175 Get the list of identity verification options for an account 2176 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/) 2177 This method makes a synchronous HTTP request by default. To make an 2178 asynchronous HTTP request, please define a `callback` function 2179 to be invoked when receiving the response. 2180 >>> def callback_function(response): 2181 >>> pprint(response) 2182 >>> 2183 >>> thread = api.get_account_identity_verification_with_http_info(account_id, callback=callback_function) 2184 2185 :param callback function: The callback function 2186 for asynchronous request. (optional) 2187 :param str account_id: The external account number (int) or account ID Guid. (required) 2188 :return: AccountIdentityVerificationResponse 2189 If the method is called asynchronously, 2190 returns the request thread. 2191 """ 2192 2193 all_params = ['account_id'] 2194 all_params.append('callback') 2195 all_params.append('_return_http_data_only') 2196 all_params.append('_preload_content') 2197 all_params.append('_request_timeout') 2198 2199 params = locals() 2200 for key, val in iteritems(params['kwargs']): 2201 if key not in all_params: 2202 raise TypeError( 2203 "Got an unexpected keyword argument '%s'" 2204 " to method get_account_identity_verification" % key 2205 ) 2206 params[key] = val 2207 del params['kwargs'] 2208 # verify the required parameter 'account_id' is set 2209 if ('account_id' not in params) or (params['account_id'] is None): 2210 raise ValueError("Missing the required parameter `account_id` when calling `get_account_identity_verification`") 2211 2212 2213 collection_formats = {} 2214 2215 resource_path = '/v2.1/accounts/{accountId}/identity_verification'.replace('{format}', 'json') 2216 path_params = {} 2217 if 'account_id' in params: 2218 path_params['accountId'] = params['account_id'] 2219 2220 query_params = {} 2221 2222 header_params = {} 2223 2224 form_params = [] 2225 local_var_files = {} 2226 2227 body_params = None 2228 # HTTP header `Accept` 2229 header_params['Accept'] = self.api_client.\ 2230 select_header_accept(['application/json']) 2231 2232 # Authentication setting 2233 auth_settings = [] 2234 2235 return self.api_client.call_api(resource_path, 'GET', 2236 path_params, 2237 query_params, 2238 header_params, 2239 body=body_params, 2240 post_params=form_params, 2241 files=local_var_files, 2242 response_type='AccountIdentityVerificationResponse', 2243 auth_settings=auth_settings, 2244 callback=params.get('callback'), 2245 _return_http_data_only=params.get('_return_http_data_only'), 2246 _preload_content=params.get('_preload_content', True), 2247 _request_timeout=params.get('_request_timeout'), 2248 collection_formats=collection_formats) 2249 2250 def get_account_information(self, account_id, **kwargs): 2251 """ 2252 Retrieves the account information for the specified account. 2253 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. 2254 This method makes a synchronous HTTP request by default. To make an 2255 asynchronous HTTP request, please define a `callback` function 2256 to be invoked when receiving the response. 2257 >>> def callback_function(response): 2258 >>> pprint(response) 2259 >>> 2260 >>> thread = api.get_account_information(account_id, callback=callback_function) 2261 2262 :param callback function: The callback function 2263 for asynchronous request. (optional) 2264 :param str account_id: The external account number (int) or account ID Guid. (required) 2265 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 2266 :return: AccountInformation 2267 If the method is called asynchronously, 2268 returns the request thread. 2269 """ 2270 kwargs['_return_http_data_only'] = True 2271 if kwargs.get('callback'): 2272 return self.get_account_information_with_http_info(account_id, **kwargs) 2273 else: 2274 (data) = self.get_account_information_with_http_info(account_id, **kwargs) 2275 return data 2276 2277 def get_account_information_with_http_info(self, account_id, **kwargs): 2278 """ 2279 Retrieves the account information for the specified account. 2280 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. 2281 This method makes a synchronous HTTP request by default. To make an 2282 asynchronous HTTP request, please define a `callback` function 2283 to be invoked when receiving the response. 2284 >>> def callback_function(response): 2285 >>> pprint(response) 2286 >>> 2287 >>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function) 2288 2289 :param callback function: The callback function 2290 for asynchronous request. (optional) 2291 :param str account_id: The external account number (int) or account ID Guid. (required) 2292 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 2293 :return: AccountInformation 2294 If the method is called asynchronously, 2295 returns the request thread. 2296 """ 2297 2298 all_params = ['account_id', 'include_account_settings'] 2299 all_params.append('callback') 2300 all_params.append('_return_http_data_only') 2301 all_params.append('_preload_content') 2302 all_params.append('_request_timeout') 2303 2304 params = locals() 2305 for key, val in iteritems(params['kwargs']): 2306 if key not in all_params: 2307 raise TypeError( 2308 "Got an unexpected keyword argument '%s'" 2309 " to method get_account_information" % key 2310 ) 2311 params[key] = val 2312 del params['kwargs'] 2313 # verify the required parameter 'account_id' is set 2314 if ('account_id' not in params) or (params['account_id'] is None): 2315 raise ValueError("Missing the required parameter `account_id` when calling `get_account_information`") 2316 2317 2318 collection_formats = {} 2319 2320 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 2321 path_params = {} 2322 if 'account_id' in params: 2323 path_params['accountId'] = params['account_id'] 2324 2325 query_params = {} 2326 if 'include_account_settings' in params: 2327 query_params['include_account_settings'] = params['include_account_settings'] 2328 2329 header_params = {} 2330 2331 form_params = [] 2332 local_var_files = {} 2333 2334 body_params = None 2335 # HTTP header `Accept` 2336 header_params['Accept'] = self.api_client.\ 2337 select_header_accept(['application/json']) 2338 2339 # Authentication setting 2340 auth_settings = [] 2341 2342 return self.api_client.call_api(resource_path, 'GET', 2343 path_params, 2344 query_params, 2345 header_params, 2346 body=body_params, 2347 post_params=form_params, 2348 files=local_var_files, 2349 response_type='AccountInformation', 2350 auth_settings=auth_settings, 2351 callback=params.get('callback'), 2352 _return_http_data_only=params.get('_return_http_data_only'), 2353 _preload_content=params.get('_preload_content', True), 2354 _request_timeout=params.get('_request_timeout'), 2355 collection_formats=collection_formats) 2356 2357 def get_account_signature(self, account_id, signature_id, **kwargs): 2358 """ 2359 Returns information about a single signature by specifed signatureId. 2360 2361 This method makes a synchronous HTTP request by default. To make an 2362 asynchronous HTTP request, please define a `callback` function 2363 to be invoked when receiving the response. 2364 >>> def callback_function(response): 2365 >>> pprint(response) 2366 >>> 2367 >>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function) 2368 2369 :param callback function: The callback function 2370 for asynchronous request. (optional) 2371 :param str account_id: The external account number (int) or account ID Guid. (required) 2372 :param str signature_id: The ID of the signature being accessed. (required) 2373 :return: AccountSignature 2374 If the method is called asynchronously, 2375 returns the request thread. 2376 """ 2377 kwargs['_return_http_data_only'] = True 2378 if kwargs.get('callback'): 2379 return self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2380 else: 2381 (data) = self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2382 return data 2383 2384 def get_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 2385 """ 2386 Returns information about a single signature by specifed signatureId. 2387 2388 This method makes a synchronous HTTP request by default. To make an 2389 asynchronous HTTP request, please define a `callback` function 2390 to be invoked when receiving the response. 2391 >>> def callback_function(response): 2392 >>> pprint(response) 2393 >>> 2394 >>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 2395 2396 :param callback function: The callback function 2397 for asynchronous request. (optional) 2398 :param str account_id: The external account number (int) or account ID Guid. (required) 2399 :param str signature_id: The ID of the signature being accessed. (required) 2400 :return: AccountSignature 2401 If the method is called asynchronously, 2402 returns the request thread. 2403 """ 2404 2405 all_params = ['account_id', 'signature_id'] 2406 all_params.append('callback') 2407 all_params.append('_return_http_data_only') 2408 all_params.append('_preload_content') 2409 all_params.append('_request_timeout') 2410 2411 params = locals() 2412 for key, val in iteritems(params['kwargs']): 2413 if key not in all_params: 2414 raise TypeError( 2415 "Got an unexpected keyword argument '%s'" 2416 " to method get_account_signature" % key 2417 ) 2418 params[key] = val 2419 del params['kwargs'] 2420 # verify the required parameter 'account_id' is set 2421 if ('account_id' not in params) or (params['account_id'] is None): 2422 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature`") 2423 # verify the required parameter 'signature_id' is set 2424 if ('signature_id' not in params) or (params['signature_id'] is None): 2425 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature`") 2426 2427 2428 collection_formats = {} 2429 2430 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 2431 path_params = {} 2432 if 'account_id' in params: 2433 path_params['accountId'] = params['account_id'] 2434 if 'signature_id' in params: 2435 path_params['signatureId'] = params['signature_id'] 2436 2437 query_params = {} 2438 2439 header_params = {} 2440 2441 form_params = [] 2442 local_var_files = {} 2443 2444 body_params = None 2445 # HTTP header `Accept` 2446 header_params['Accept'] = self.api_client.\ 2447 select_header_accept(['application/json']) 2448 2449 # Authentication setting 2450 auth_settings = [] 2451 2452 return self.api_client.call_api(resource_path, 'GET', 2453 path_params, 2454 query_params, 2455 header_params, 2456 body=body_params, 2457 post_params=form_params, 2458 files=local_var_files, 2459 response_type='AccountSignature', 2460 auth_settings=auth_settings, 2461 callback=params.get('callback'), 2462 _return_http_data_only=params.get('_return_http_data_only'), 2463 _preload_content=params.get('_preload_content', True), 2464 _request_timeout=params.get('_request_timeout'), 2465 collection_formats=collection_formats) 2466 2467 def get_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 2468 """ 2469 Returns a signature, initials, or stamps image. 2470 2471 This method makes a synchronous HTTP request by default. To make an 2472 asynchronous HTTP request, please define a `callback` function 2473 to be invoked when receiving the response. 2474 >>> def callback_function(response): 2475 >>> pprint(response) 2476 >>> 2477 >>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 2478 2479 :param callback function: The callback function 2480 for asynchronous request. (optional) 2481 :param str account_id: The external account number (int) or account ID Guid. (required) 2482 :param str image_type: One of **signature_image** or **initials_image**. (required) 2483 :param str signature_id: The ID of the signature being accessed. (required) 2484 :param str include_chrome: 2485 :return: file 2486 If the method is called asynchronously, 2487 returns the request thread. 2488 """ 2489 kwargs['_return_http_data_only'] = True 2490 if kwargs.get('callback'): 2491 return self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2492 else: 2493 (data) = self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2494 return data 2495 2496 def get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 2497 """ 2498 Returns a signature, initials, or stamps image. 2499 2500 This method makes a synchronous HTTP request by default. To make an 2501 asynchronous HTTP request, please define a `callback` function 2502 to be invoked when receiving the response. 2503 >>> def callback_function(response): 2504 >>> pprint(response) 2505 >>> 2506 >>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 2507 2508 :param callback function: The callback function 2509 for asynchronous request. (optional) 2510 :param str account_id: The external account number (int) or account ID Guid. (required) 2511 :param str image_type: One of **signature_image** or **initials_image**. (required) 2512 :param str signature_id: The ID of the signature being accessed. (required) 2513 :param str include_chrome: 2514 :return: file 2515 If the method is called asynchronously, 2516 returns the request thread. 2517 """ 2518 2519 all_params = ['account_id', 'image_type', 'signature_id', 'include_chrome'] 2520 all_params.append('callback') 2521 all_params.append('_return_http_data_only') 2522 all_params.append('_preload_content') 2523 all_params.append('_request_timeout') 2524 2525 params = locals() 2526 for key, val in iteritems(params['kwargs']): 2527 if key not in all_params: 2528 raise TypeError( 2529 "Got an unexpected keyword argument '%s'" 2530 " to method get_account_signature_image" % key 2531 ) 2532 params[key] = val 2533 del params['kwargs'] 2534 # verify the required parameter 'account_id' is set 2535 if ('account_id' not in params) or (params['account_id'] is None): 2536 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature_image`") 2537 # verify the required parameter 'image_type' is set 2538 if ('image_type' not in params) or (params['image_type'] is None): 2539 raise ValueError("Missing the required parameter `image_type` when calling `get_account_signature_image`") 2540 # verify the required parameter 'signature_id' is set 2541 if ('signature_id' not in params) or (params['signature_id'] is None): 2542 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature_image`") 2543 2544 2545 collection_formats = {} 2546 2547 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 2548 path_params = {} 2549 if 'account_id' in params: 2550 path_params['accountId'] = params['account_id'] 2551 if 'image_type' in params: 2552 path_params['imageType'] = params['image_type'] 2553 if 'signature_id' in params: 2554 path_params['signatureId'] = params['signature_id'] 2555 2556 query_params = {} 2557 if 'include_chrome' in params: 2558 query_params['include_chrome'] = params['include_chrome'] 2559 2560 header_params = {} 2561 2562 form_params = [] 2563 local_var_files = {} 2564 2565 body_params = None 2566 # HTTP header `Accept` 2567 header_params['Accept'] = self.api_client.\ 2568 select_header_accept(['image/gif']) 2569 2570 # Authentication setting 2571 auth_settings = [] 2572 2573 return self.api_client.call_api(resource_path, 'GET', 2574 path_params, 2575 query_params, 2576 header_params, 2577 body=body_params, 2578 post_params=form_params, 2579 files=local_var_files, 2580 response_type='file', 2581 auth_settings=auth_settings, 2582 callback=params.get('callback'), 2583 _return_http_data_only=params.get('_return_http_data_only'), 2584 _preload_content=params.get('_preload_content', True), 2585 _request_timeout=params.get('_request_timeout'), 2586 collection_formats=collection_formats) 2587 2588 def get_account_signatures(self, account_id, **kwargs): 2589 """ 2590 Returns the managed signature definitions for the account 2591 2592 This method makes a synchronous HTTP request by default. To make an 2593 asynchronous HTTP request, please define a `callback` function 2594 to be invoked when receiving the response. 2595 >>> def callback_function(response): 2596 >>> pprint(response) 2597 >>> 2598 >>> thread = api.get_account_signatures(account_id, callback=callback_function) 2599 2600 :param callback function: The callback function 2601 for asynchronous request. (optional) 2602 :param str account_id: The external account number (int) or account ID Guid. (required) 2603 :param str stamp_format: 2604 :param str stamp_name: 2605 :param str stamp_type: 2606 :return: AccountSignaturesInformation 2607 If the method is called asynchronously, 2608 returns the request thread. 2609 """ 2610 kwargs['_return_http_data_only'] = True 2611 if kwargs.get('callback'): 2612 return self.get_account_signatures_with_http_info(account_id, **kwargs) 2613 else: 2614 (data) = self.get_account_signatures_with_http_info(account_id, **kwargs) 2615 return data 2616 2617 def get_account_signatures_with_http_info(self, account_id, **kwargs): 2618 """ 2619 Returns the managed signature definitions for the account 2620 2621 This method makes a synchronous HTTP request by default. To make an 2622 asynchronous HTTP request, please define a `callback` function 2623 to be invoked when receiving the response. 2624 >>> def callback_function(response): 2625 >>> pprint(response) 2626 >>> 2627 >>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function) 2628 2629 :param callback function: The callback function 2630 for asynchronous request. (optional) 2631 :param str account_id: The external account number (int) or account ID Guid. (required) 2632 :param str stamp_format: 2633 :param str stamp_name: 2634 :param str stamp_type: 2635 :return: AccountSignaturesInformation 2636 If the method is called asynchronously, 2637 returns the request thread. 2638 """ 2639 2640 all_params = ['account_id', 'stamp_format', 'stamp_name', 'stamp_type'] 2641 all_params.append('callback') 2642 all_params.append('_return_http_data_only') 2643 all_params.append('_preload_content') 2644 all_params.append('_request_timeout') 2645 2646 params = locals() 2647 for key, val in iteritems(params['kwargs']): 2648 if key not in all_params: 2649 raise TypeError( 2650 "Got an unexpected keyword argument '%s'" 2651 " to method get_account_signatures" % key 2652 ) 2653 params[key] = val 2654 del params['kwargs'] 2655 # verify the required parameter 'account_id' is set 2656 if ('account_id' not in params) or (params['account_id'] is None): 2657 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signatures`") 2658 2659 2660 collection_formats = {} 2661 2662 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 2663 path_params = {} 2664 if 'account_id' in params: 2665 path_params['accountId'] = params['account_id'] 2666 2667 query_params = {} 2668 if 'stamp_format' in params: 2669 query_params['stamp_format'] = params['stamp_format'] 2670 if 'stamp_name' in params: 2671 query_params['stamp_name'] = params['stamp_name'] 2672 if 'stamp_type' in params: 2673 query_params['stamp_type'] = params['stamp_type'] 2674 2675 header_params = {} 2676 2677 form_params = [] 2678 local_var_files = {} 2679 2680 body_params = None 2681 # HTTP header `Accept` 2682 header_params['Accept'] = self.api_client.\ 2683 select_header_accept(['application/json']) 2684 2685 # Authentication setting 2686 auth_settings = [] 2687 2688 return self.api_client.call_api(resource_path, 'GET', 2689 path_params, 2690 query_params, 2691 header_params, 2692 body=body_params, 2693 post_params=form_params, 2694 files=local_var_files, 2695 response_type='AccountSignaturesInformation', 2696 auth_settings=auth_settings, 2697 callback=params.get('callback'), 2698 _return_http_data_only=params.get('_return_http_data_only'), 2699 _preload_content=params.get('_preload_content', True), 2700 _request_timeout=params.get('_request_timeout'), 2701 collection_formats=collection_formats) 2702 2703 def get_account_tab_settings(self, account_id, **kwargs): 2704 """ 2705 Returns tab settings list for specified account 2706 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2707 This method makes a synchronous HTTP request by default. To make an 2708 asynchronous HTTP request, please define a `callback` function 2709 to be invoked when receiving the response. 2710 >>> def callback_function(response): 2711 >>> pprint(response) 2712 >>> 2713 >>> thread = api.get_account_tab_settings(account_id, callback=callback_function) 2714 2715 :param callback function: The callback function 2716 for asynchronous request. (optional) 2717 :param str account_id: The external account number (int) or account ID Guid. (required) 2718 :return: TabAccountSettings 2719 If the method is called asynchronously, 2720 returns the request thread. 2721 """ 2722 kwargs['_return_http_data_only'] = True 2723 if kwargs.get('callback'): 2724 return self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2725 else: 2726 (data) = self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2727 return data 2728 2729 def get_account_tab_settings_with_http_info(self, account_id, **kwargs): 2730 """ 2731 Returns tab settings list for specified account 2732 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2733 This method makes a synchronous HTTP request by default. To make an 2734 asynchronous HTTP request, please define a `callback` function 2735 to be invoked when receiving the response. 2736 >>> def callback_function(response): 2737 >>> pprint(response) 2738 >>> 2739 >>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function) 2740 2741 :param callback function: The callback function 2742 for asynchronous request. (optional) 2743 :param str account_id: The external account number (int) or account ID Guid. (required) 2744 :return: TabAccountSettings 2745 If the method is called asynchronously, 2746 returns the request thread. 2747 """ 2748 2749 all_params = ['account_id'] 2750 all_params.append('callback') 2751 all_params.append('_return_http_data_only') 2752 all_params.append('_preload_content') 2753 all_params.append('_request_timeout') 2754 2755 params = locals() 2756 for key, val in iteritems(params['kwargs']): 2757 if key not in all_params: 2758 raise TypeError( 2759 "Got an unexpected keyword argument '%s'" 2760 " to method get_account_tab_settings" % key 2761 ) 2762 params[key] = val 2763 del params['kwargs'] 2764 # verify the required parameter 'account_id' is set 2765 if ('account_id' not in params) or (params['account_id'] is None): 2766 raise ValueError("Missing the required parameter `account_id` when calling `get_account_tab_settings`") 2767 2768 2769 collection_formats = {} 2770 2771 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 2772 path_params = {} 2773 if 'account_id' in params: 2774 path_params['accountId'] = params['account_id'] 2775 2776 query_params = {} 2777 2778 header_params = {} 2779 2780 form_params = [] 2781 local_var_files = {} 2782 2783 body_params = None 2784 # HTTP header `Accept` 2785 header_params['Accept'] = self.api_client.\ 2786 select_header_accept(['application/json']) 2787 2788 # Authentication setting 2789 auth_settings = [] 2790 2791 return self.api_client.call_api(resource_path, 'GET', 2792 path_params, 2793 query_params, 2794 header_params, 2795 body=body_params, 2796 post_params=form_params, 2797 files=local_var_files, 2798 response_type='TabAccountSettings', 2799 auth_settings=auth_settings, 2800 callback=params.get('callback'), 2801 _return_http_data_only=params.get('_return_http_data_only'), 2802 _preload_content=params.get('_preload_content', True), 2803 _request_timeout=params.get('_request_timeout'), 2804 collection_formats=collection_formats) 2805 2806 def get_agent_user_authorizations(self, account_id, user_id, **kwargs): 2807 """ 2808 Returns the agent user authorizations 2809 This method makes a synchronous HTTP request by default. To make an 2810 asynchronous HTTP request, please define a `callback` function 2811 to be invoked when receiving the response. 2812 >>> def callback_function(response): 2813 >>> pprint(response) 2814 >>> 2815 >>> thread = api.get_agent_user_authorizations(account_id, user_id, callback=callback_function) 2816 2817 :param callback function: The callback function 2818 for asynchronous request. (optional) 2819 :param str account_id: The external account number (int) or account ID Guid. (required) 2820 :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) 2821 :param str active_only: 2822 :param str count: 2823 :param str email_substring: Part (substring) of email we are searching for. 2824 :param str include_closed_users: 2825 :param str permissions: 2826 :param str start_position: 2827 :param str user_name_substring: 2828 :return: UserAuthorizations 2829 If the method is called asynchronously, 2830 returns the request thread. 2831 """ 2832 kwargs['_return_http_data_only'] = True 2833 if kwargs.get('callback'): 2834 return self.get_agent_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2835 else: 2836 (data) = self.get_agent_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2837 return data 2838 2839 def get_agent_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 2840 """ 2841 Returns the agent user authorizations 2842 This method makes a synchronous HTTP request by default. To make an 2843 asynchronous HTTP request, please define a `callback` function 2844 to be invoked when receiving the response. 2845 >>> def callback_function(response): 2846 >>> pprint(response) 2847 >>> 2848 >>> thread = api.get_agent_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 2849 2850 :param callback function: The callback function 2851 for asynchronous request. (optional) 2852 :param str account_id: The external account number (int) or account ID Guid. (required) 2853 :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) 2854 :param str active_only: 2855 :param str count: 2856 :param str email_substring: Part (substring) of email we are searching for. 2857 :param str include_closed_users: 2858 :param str permissions: 2859 :param str start_position: 2860 :param str user_name_substring: 2861 :return: UserAuthorizations 2862 If the method is called asynchronously, 2863 returns the request thread. 2864 """ 2865 2866 all_params = ['account_id', 'user_id', 'active_only', 'count', 'email_substring', 'include_closed_users', 'permissions', 'start_position', 'user_name_substring'] 2867 all_params.append('callback') 2868 all_params.append('_return_http_data_only') 2869 all_params.append('_preload_content') 2870 all_params.append('_request_timeout') 2871 2872 params = locals() 2873 for key, val in iteritems(params['kwargs']): 2874 if key not in all_params: 2875 raise TypeError( 2876 "Got an unexpected keyword argument '%s'" 2877 " to method get_agent_user_authorizations" % key 2878 ) 2879 params[key] = val 2880 del params['kwargs'] 2881 # verify the required parameter 'account_id' is set 2882 if ('account_id' not in params) or (params['account_id'] is None): 2883 raise ValueError("Missing the required parameter `account_id` when calling `get_agent_user_authorizations`") 2884 # verify the required parameter 'user_id' is set 2885 if ('user_id' not in params) or (params['user_id'] is None): 2886 raise ValueError("Missing the required parameter `user_id` when calling `get_agent_user_authorizations`") 2887 2888 2889 collection_formats = {} 2890 2891 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations/agent'.replace('{format}', 'json') 2892 path_params = {} 2893 if 'account_id' in params: 2894 path_params['accountId'] = params['account_id'] 2895 if 'user_id' in params: 2896 path_params['userId'] = params['user_id'] 2897 2898 query_params = {} 2899 if 'active_only' in params: 2900 query_params['active_only'] = params['active_only'] 2901 if 'count' in params: 2902 query_params['count'] = params['count'] 2903 if 'email_substring' in params: 2904 query_params['email_substring'] = params['email_substring'] 2905 if 'include_closed_users' in params: 2906 query_params['include_closed_users'] = params['include_closed_users'] 2907 if 'permissions' in params: 2908 query_params['permissions'] = params['permissions'] 2909 if 'start_position' in params: 2910 query_params['start_position'] = params['start_position'] 2911 if 'user_name_substring' in params: 2912 query_params['user_name_substring'] = params['user_name_substring'] 2913 2914 header_params = {} 2915 2916 form_params = [] 2917 local_var_files = {} 2918 2919 body_params = None 2920 # HTTP header `Accept` 2921 header_params['Accept'] = self.api_client.\ 2922 select_header_accept(['application/json']) 2923 2924 # Authentication setting 2925 auth_settings = [] 2926 2927 return self.api_client.call_api(resource_path, 'GET', 2928 path_params, 2929 query_params, 2930 header_params, 2931 body=body_params, 2932 post_params=form_params, 2933 files=local_var_files, 2934 response_type='UserAuthorizations', 2935 auth_settings=auth_settings, 2936 callback=params.get('callback'), 2937 _return_http_data_only=params.get('_return_http_data_only'), 2938 _preload_content=params.get('_preload_content', True), 2939 _request_timeout=params.get('_request_timeout'), 2940 collection_formats=collection_formats) 2941 2942 def get_all_payment_gateway_accounts(self, account_id, **kwargs): 2943 """ 2944 Get all payment gateway account for the provided accountId 2945 This method returns a list of payment gateway accounts and basic information about them. 2946 This method makes a synchronous HTTP request by default. To make an 2947 asynchronous HTTP request, please define a `callback` function 2948 to be invoked when receiving the response. 2949 >>> def callback_function(response): 2950 >>> pprint(response) 2951 >>> 2952 >>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function) 2953 2954 :param callback function: The callback function 2955 for asynchronous request. (optional) 2956 :param str account_id: The external account number (int) or account ID Guid. (required) 2957 :return: PaymentGatewayAccountsInfo 2958 If the method is called asynchronously, 2959 returns the request thread. 2960 """ 2961 kwargs['_return_http_data_only'] = True 2962 if kwargs.get('callback'): 2963 return self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2964 else: 2965 (data) = self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2966 return data 2967 2968 def get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs): 2969 """ 2970 Get all payment gateway account for the provided accountId 2971 This method returns a list of payment gateway accounts and basic information about them. 2972 This method makes a synchronous HTTP request by default. To make an 2973 asynchronous HTTP request, please define a `callback` function 2974 to be invoked when receiving the response. 2975 >>> def callback_function(response): 2976 >>> pprint(response) 2977 >>> 2978 >>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function) 2979 2980 :param callback function: The callback function 2981 for asynchronous request. (optional) 2982 :param str account_id: The external account number (int) or account ID Guid. (required) 2983 :return: PaymentGatewayAccountsInfo 2984 If the method is called asynchronously, 2985 returns the request thread. 2986 """ 2987 2988 all_params = ['account_id'] 2989 all_params.append('callback') 2990 all_params.append('_return_http_data_only') 2991 all_params.append('_preload_content') 2992 all_params.append('_request_timeout') 2993 2994 params = locals() 2995 for key, val in iteritems(params['kwargs']): 2996 if key not in all_params: 2997 raise TypeError( 2998 "Got an unexpected keyword argument '%s'" 2999 " to method get_all_payment_gateway_accounts" % key 3000 ) 3001 params[key] = val 3002 del params['kwargs'] 3003 # verify the required parameter 'account_id' is set 3004 if ('account_id' not in params) or (params['account_id'] is None): 3005 raise ValueError("Missing the required parameter `account_id` when calling `get_all_payment_gateway_accounts`") 3006 3007 3008 collection_formats = {} 3009 3010 resource_path = '/v2.1/accounts/{accountId}/payment_gateway_accounts'.replace('{format}', 'json') 3011 path_params = {} 3012 if 'account_id' in params: 3013 path_params['accountId'] = params['account_id'] 3014 3015 query_params = {} 3016 3017 header_params = {} 3018 3019 form_params = [] 3020 local_var_files = {} 3021 3022 body_params = None 3023 # HTTP header `Accept` 3024 header_params['Accept'] = self.api_client.\ 3025 select_header_accept(['application/json']) 3026 3027 # Authentication setting 3028 auth_settings = [] 3029 3030 return self.api_client.call_api(resource_path, 'GET', 3031 path_params, 3032 query_params, 3033 header_params, 3034 body=body_params, 3035 post_params=form_params, 3036 files=local_var_files, 3037 response_type='PaymentGatewayAccountsInfo', 3038 auth_settings=auth_settings, 3039 callback=params.get('callback'), 3040 _return_http_data_only=params.get('_return_http_data_only'), 3041 _preload_content=params.get('_preload_content', True), 3042 _request_timeout=params.get('_request_timeout'), 3043 collection_formats=collection_formats) 3044 3045 def get_billing_charges(self, account_id, **kwargs): 3046 """ 3047 Gets list of recurring and usage charges for the account. 3048 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 3049 This method makes a synchronous HTTP request by default. To make an 3050 asynchronous HTTP request, please define a `callback` function 3051 to be invoked when receiving the response. 3052 >>> def callback_function(response): 3053 >>> pprint(response) 3054 >>> 3055 >>> thread = api.get_billing_charges(account_id, callback=callback_function) 3056 3057 :param callback function: The callback function 3058 for asynchronous request. (optional) 3059 :param str account_id: The external account number (int) or account ID Guid. (required) 3060 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3061 :return: BillingChargeResponse 3062 If the method is called asynchronously, 3063 returns the request thread. 3064 """ 3065 kwargs['_return_http_data_only'] = True 3066 if kwargs.get('callback'): 3067 return self.get_billing_charges_with_http_info(account_id, **kwargs) 3068 else: 3069 (data) = self.get_billing_charges_with_http_info(account_id, **kwargs) 3070 return data 3071 3072 def get_billing_charges_with_http_info(self, account_id, **kwargs): 3073 """ 3074 Gets list of recurring and usage charges for the account. 3075 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 3076 This method makes a synchronous HTTP request by default. To make an 3077 asynchronous HTTP request, please define a `callback` function 3078 to be invoked when receiving the response. 3079 >>> def callback_function(response): 3080 >>> pprint(response) 3081 >>> 3082 >>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function) 3083 3084 :param callback function: The callback function 3085 for asynchronous request. (optional) 3086 :param str account_id: The external account number (int) or account ID Guid. (required) 3087 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3088 :return: BillingChargeResponse 3089 If the method is called asynchronously, 3090 returns the request thread. 3091 """ 3092 3093 all_params = ['account_id', 'include_charges'] 3094 all_params.append('callback') 3095 all_params.append('_return_http_data_only') 3096 all_params.append('_preload_content') 3097 all_params.append('_request_timeout') 3098 3099 params = locals() 3100 for key, val in iteritems(params['kwargs']): 3101 if key not in all_params: 3102 raise TypeError( 3103 "Got an unexpected keyword argument '%s'" 3104 " to method get_billing_charges" % key 3105 ) 3106 params[key] = val 3107 del params['kwargs'] 3108 # verify the required parameter 'account_id' is set 3109 if ('account_id' not in params) or (params['account_id'] is None): 3110 raise ValueError("Missing the required parameter `account_id` when calling `get_billing_charges`") 3111 3112 3113 collection_formats = {} 3114 3115 resource_path = '/v2.1/accounts/{accountId}/billing_charges'.replace('{format}', 'json') 3116 path_params = {} 3117 if 'account_id' in params: 3118 path_params['accountId'] = params['account_id'] 3119 3120 query_params = {} 3121 if 'include_charges' in params: 3122 query_params['include_charges'] = params['include_charges'] 3123 3124 header_params = {} 3125 3126 form_params = [] 3127 local_var_files = {} 3128 3129 body_params = None 3130 # HTTP header `Accept` 3131 header_params['Accept'] = self.api_client.\ 3132 select_header_accept(['application/json']) 3133 3134 # Authentication setting 3135 auth_settings = [] 3136 3137 return self.api_client.call_api(resource_path, 'GET', 3138 path_params, 3139 query_params, 3140 header_params, 3141 body=body_params, 3142 post_params=form_params, 3143 files=local_var_files, 3144 response_type='BillingChargeResponse', 3145 auth_settings=auth_settings, 3146 callback=params.get('callback'), 3147 _return_http_data_only=params.get('_return_http_data_only'), 3148 _preload_content=params.get('_preload_content', True), 3149 _request_timeout=params.get('_request_timeout'), 3150 collection_formats=collection_formats) 3151 3152 def get_brand(self, account_id, brand_id, **kwargs): 3153 """ 3154 Get information for a specific brand. 3155 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**). 3156 This method makes a synchronous HTTP request by default. To make an 3157 asynchronous HTTP request, please define a `callback` function 3158 to be invoked when receiving the response. 3159 >>> def callback_function(response): 3160 >>> pprint(response) 3161 >>> 3162 >>> thread = api.get_brand(account_id, brand_id, callback=callback_function) 3163 3164 :param callback function: The callback function 3165 for asynchronous request. (optional) 3166 :param str account_id: The external account number (int) or account ID Guid. (required) 3167 :param str brand_id: The unique identifier of a brand. (required) 3168 :param str include_external_references: 3169 :param str include_logos: 3170 :return: Brand 3171 If the method is called asynchronously, 3172 returns the request thread. 3173 """ 3174 kwargs['_return_http_data_only'] = True 3175 if kwargs.get('callback'): 3176 return self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3177 else: 3178 (data) = self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3179 return data 3180 3181 def get_brand_with_http_info(self, account_id, brand_id, **kwargs): 3182 """ 3183 Get information for a specific brand. 3184 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**). 3185 This method makes a synchronous HTTP request by default. To make an 3186 asynchronous HTTP request, please define a `callback` function 3187 to be invoked when receiving the response. 3188 >>> def callback_function(response): 3189 >>> pprint(response) 3190 >>> 3191 >>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function) 3192 3193 :param callback function: The callback function 3194 for asynchronous request. (optional) 3195 :param str account_id: The external account number (int) or account ID Guid. (required) 3196 :param str brand_id: The unique identifier of a brand. (required) 3197 :param str include_external_references: 3198 :param str include_logos: 3199 :return: Brand 3200 If the method is called asynchronously, 3201 returns the request thread. 3202 """ 3203 3204 all_params = ['account_id', 'brand_id', 'include_external_references', 'include_logos'] 3205 all_params.append('callback') 3206 all_params.append('_return_http_data_only') 3207 all_params.append('_preload_content') 3208 all_params.append('_request_timeout') 3209 3210 params = locals() 3211 for key, val in iteritems(params['kwargs']): 3212 if key not in all_params: 3213 raise TypeError( 3214 "Got an unexpected keyword argument '%s'" 3215 " to method get_brand" % key 3216 ) 3217 params[key] = val 3218 del params['kwargs'] 3219 # verify the required parameter 'account_id' is set 3220 if ('account_id' not in params) or (params['account_id'] is None): 3221 raise ValueError("Missing the required parameter `account_id` when calling `get_brand`") 3222 # verify the required parameter 'brand_id' is set 3223 if ('brand_id' not in params) or (params['brand_id'] is None): 3224 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand`") 3225 3226 3227 collection_formats = {} 3228 3229 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 3230 path_params = {} 3231 if 'account_id' in params: 3232 path_params['accountId'] = params['account_id'] 3233 if 'brand_id' in params: 3234 path_params['brandId'] = params['brand_id'] 3235 3236 query_params = {} 3237 if 'include_external_references' in params: 3238 query_params['include_external_references'] = params['include_external_references'] 3239 if 'include_logos' in params: 3240 query_params['include_logos'] = params['include_logos'] 3241 3242 header_params = {} 3243 3244 form_params = [] 3245 local_var_files = {} 3246 3247 body_params = None 3248 # HTTP header `Accept` 3249 header_params['Accept'] = self.api_client.\ 3250 select_header_accept(['application/json']) 3251 3252 # Authentication setting 3253 auth_settings = [] 3254 3255 return self.api_client.call_api(resource_path, 'GET', 3256 path_params, 3257 query_params, 3258 header_params, 3259 body=body_params, 3260 post_params=form_params, 3261 files=local_var_files, 3262 response_type='Brand', 3263 auth_settings=auth_settings, 3264 callback=params.get('callback'), 3265 _return_http_data_only=params.get('_return_http_data_only'), 3266 _preload_content=params.get('_preload_content', True), 3267 _request_timeout=params.get('_request_timeout'), 3268 collection_formats=collection_formats) 3269 3270 def get_brand_export_file(self, account_id, brand_id, **kwargs): 3271 """ 3272 Export a specific brand. 3273 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**). 3274 This method makes a synchronous HTTP request by default. To make an 3275 asynchronous HTTP request, please define a `callback` function 3276 to be invoked when receiving the response. 3277 >>> def callback_function(response): 3278 >>> pprint(response) 3279 >>> 3280 >>> thread = api.get_brand_export_file(account_id, brand_id, callback=callback_function) 3281 3282 :param callback function: The callback function 3283 for asynchronous request. (optional) 3284 :param str account_id: The external account number (int) or account ID Guid. (required) 3285 :param str brand_id: The unique identifier of a brand. (required) 3286 :return: None 3287 If the method is called asynchronously, 3288 returns the request thread. 3289 """ 3290 kwargs['_return_http_data_only'] = True 3291 if kwargs.get('callback'): 3292 return self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3293 else: 3294 (data) = self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3295 return data 3296 3297 def get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs): 3298 """ 3299 Export a specific brand. 3300 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**). 3301 This method makes a synchronous HTTP request by default. To make an 3302 asynchronous HTTP request, please define a `callback` function 3303 to be invoked when receiving the response. 3304 >>> def callback_function(response): 3305 >>> pprint(response) 3306 >>> 3307 >>> thread = api.get_brand_export_file_with_http_info(account_id, brand_id, callback=callback_function) 3308 3309 :param callback function: The callback function 3310 for asynchronous request. (optional) 3311 :param str account_id: The external account number (int) or account ID Guid. (required) 3312 :param str brand_id: The unique identifier of a brand. (required) 3313 :return: None 3314 If the method is called asynchronously, 3315 returns the request thread. 3316 """ 3317 3318 all_params = ['account_id', 'brand_id'] 3319 all_params.append('callback') 3320 all_params.append('_return_http_data_only') 3321 all_params.append('_preload_content') 3322 all_params.append('_request_timeout') 3323 3324 params = locals() 3325 for key, val in iteritems(params['kwargs']): 3326 if key not in all_params: 3327 raise TypeError( 3328 "Got an unexpected keyword argument '%s'" 3329 " to method get_brand_export_file" % key 3330 ) 3331 params[key] = val 3332 del params['kwargs'] 3333 # verify the required parameter 'account_id' is set 3334 if ('account_id' not in params) or (params['account_id'] is None): 3335 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_export_file`") 3336 # verify the required parameter 'brand_id' is set 3337 if ('brand_id' not in params) or (params['brand_id'] is None): 3338 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_export_file`") 3339 3340 3341 collection_formats = {} 3342 3343 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/file'.replace('{format}', 'json') 3344 path_params = {} 3345 if 'account_id' in params: 3346 path_params['accountId'] = params['account_id'] 3347 if 'brand_id' in params: 3348 path_params['brandId'] = params['brand_id'] 3349 3350 query_params = {} 3351 3352 header_params = {} 3353 3354 form_params = [] 3355 local_var_files = {} 3356 3357 body_params = None 3358 # HTTP header `Accept` 3359 header_params['Accept'] = self.api_client.\ 3360 select_header_accept(['application/json']) 3361 3362 # Authentication setting 3363 auth_settings = [] 3364 3365 return self.api_client.call_api(resource_path, 'GET', 3366 path_params, 3367 query_params, 3368 header_params, 3369 body=body_params, 3370 post_params=form_params, 3371 files=local_var_files, 3372 response_type=None, 3373 auth_settings=auth_settings, 3374 callback=params.get('callback'), 3375 _return_http_data_only=params.get('_return_http_data_only'), 3376 _preload_content=params.get('_preload_content', True), 3377 _request_timeout=params.get('_request_timeout'), 3378 collection_formats=collection_formats) 3379 3380 def get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 3381 """ 3382 Obtains the specified image for a brand. 3383 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**). 3384 This method makes a synchronous HTTP request by default. To make an 3385 asynchronous HTTP request, please define a `callback` function 3386 to be invoked when receiving the response. 3387 >>> def callback_function(response): 3388 >>> pprint(response) 3389 >>> 3390 >>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 3391 3392 :param callback function: The callback function 3393 for asynchronous request. (optional) 3394 :param str account_id: The external account number (int) or account ID Guid. (required) 3395 :param str brand_id: The unique identifier of a brand. (required) 3396 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3397 :return: file 3398 If the method is called asynchronously, 3399 returns the request thread. 3400 """ 3401 kwargs['_return_http_data_only'] = True 3402 if kwargs.get('callback'): 3403 return self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3404 else: 3405 (data) = self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3406 return data 3407 3408 def get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 3409 """ 3410 Obtains the specified image for a brand. 3411 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**). 3412 This method makes a synchronous HTTP request by default. To make an 3413 asynchronous HTTP request, please define a `callback` function 3414 to be invoked when receiving the response. 3415 >>> def callback_function(response): 3416 >>> pprint(response) 3417 >>> 3418 >>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 3419 3420 :param callback function: The callback function 3421 for asynchronous request. (optional) 3422 :param str account_id: The external account number (int) or account ID Guid. (required) 3423 :param str brand_id: The unique identifier of a brand. (required) 3424 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3425 :return: file 3426 If the method is called asynchronously, 3427 returns the request thread. 3428 """ 3429 3430 all_params = ['account_id', 'brand_id', 'logo_type'] 3431 all_params.append('callback') 3432 all_params.append('_return_http_data_only') 3433 all_params.append('_preload_content') 3434 all_params.append('_request_timeout') 3435 3436 params = locals() 3437 for key, val in iteritems(params['kwargs']): 3438 if key not in all_params: 3439 raise TypeError( 3440 "Got an unexpected keyword argument '%s'" 3441 " to method get_brand_logo_by_type" % key 3442 ) 3443 params[key] = val 3444 del params['kwargs'] 3445 # verify the required parameter 'account_id' is set 3446 if ('account_id' not in params) or (params['account_id'] is None): 3447 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_logo_by_type`") 3448 # verify the required parameter 'brand_id' is set 3449 if ('brand_id' not in params) or (params['brand_id'] is None): 3450 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_logo_by_type`") 3451 # verify the required parameter 'logo_type' is set 3452 if ('logo_type' not in params) or (params['logo_type'] is None): 3453 raise ValueError("Missing the required parameter `logo_type` when calling `get_brand_logo_by_type`") 3454 3455 3456 collection_formats = {} 3457 3458 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 3459 path_params = {} 3460 if 'account_id' in params: 3461 path_params['accountId'] = params['account_id'] 3462 if 'brand_id' in params: 3463 path_params['brandId'] = params['brand_id'] 3464 if 'logo_type' in params: 3465 path_params['logoType'] = params['logo_type'] 3466 3467 query_params = {} 3468 3469 header_params = {} 3470 3471 form_params = [] 3472 local_var_files = {} 3473 3474 body_params = None 3475 # HTTP header `Accept` 3476 header_params['Accept'] = self.api_client.\ 3477 select_header_accept(['image/png']) 3478 3479 # Authentication setting 3480 auth_settings = [] 3481 3482 return self.api_client.call_api(resource_path, 'GET', 3483 path_params, 3484 query_params, 3485 header_params, 3486 body=body_params, 3487 post_params=form_params, 3488 files=local_var_files, 3489 response_type='file', 3490 auth_settings=auth_settings, 3491 callback=params.get('callback'), 3492 _return_http_data_only=params.get('_return_http_data_only'), 3493 _preload_content=params.get('_preload_content', True), 3494 _request_timeout=params.get('_request_timeout'), 3495 collection_formats=collection_formats) 3496 3497 def get_brand_resources(self, account_id, brand_id, **kwargs): 3498 """ 3499 Returns the specified account's list of branding resources (metadata). 3500 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**). 3501 This method makes a synchronous HTTP request by default. To make an 3502 asynchronous HTTP request, please define a `callback` function 3503 to be invoked when receiving the response. 3504 >>> def callback_function(response): 3505 >>> pprint(response) 3506 >>> 3507 >>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function) 3508 3509 :param callback function: The callback function 3510 for asynchronous request. (optional) 3511 :param str account_id: The external account number (int) or account ID Guid. (required) 3512 :param str brand_id: The unique identifier of a brand. (required) 3513 :return: BrandResourcesList 3514 If the method is called asynchronously, 3515 returns the request thread. 3516 """ 3517 kwargs['_return_http_data_only'] = True 3518 if kwargs.get('callback'): 3519 return self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3520 else: 3521 (data) = self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3522 return data 3523 3524 def get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs): 3525 """ 3526 Returns the specified account's list of branding resources (metadata). 3527 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**). 3528 This method makes a synchronous HTTP request by default. To make an 3529 asynchronous HTTP request, please define a `callback` function 3530 to be invoked when receiving the response. 3531 >>> def callback_function(response): 3532 >>> pprint(response) 3533 >>> 3534 >>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function) 3535 3536 :param callback function: The callback function 3537 for asynchronous request. (optional) 3538 :param str account_id: The external account number (int) or account ID Guid. (required) 3539 :param str brand_id: The unique identifier of a brand. (required) 3540 :return: BrandResourcesList 3541 If the method is called asynchronously, 3542 returns the request thread. 3543 """ 3544 3545 all_params = ['account_id', 'brand_id'] 3546 all_params.append('callback') 3547 all_params.append('_return_http_data_only') 3548 all_params.append('_preload_content') 3549 all_params.append('_request_timeout') 3550 3551 params = locals() 3552 for key, val in iteritems(params['kwargs']): 3553 if key not in all_params: 3554 raise TypeError( 3555 "Got an unexpected keyword argument '%s'" 3556 " to method get_brand_resources" % key 3557 ) 3558 params[key] = val 3559 del params['kwargs'] 3560 # verify the required parameter 'account_id' is set 3561 if ('account_id' not in params) or (params['account_id'] is None): 3562 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources`") 3563 # verify the required parameter 'brand_id' is set 3564 if ('brand_id' not in params) or (params['brand_id'] is None): 3565 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources`") 3566 3567 3568 collection_formats = {} 3569 3570 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources'.replace('{format}', 'json') 3571 path_params = {} 3572 if 'account_id' in params: 3573 path_params['accountId'] = params['account_id'] 3574 if 'brand_id' in params: 3575 path_params['brandId'] = params['brand_id'] 3576 3577 query_params = {} 3578 3579 header_params = {} 3580 3581 form_params = [] 3582 local_var_files = {} 3583 3584 body_params = None 3585 # HTTP header `Accept` 3586 header_params['Accept'] = self.api_client.\ 3587 select_header_accept(['application/json']) 3588 3589 # Authentication setting 3590 auth_settings = [] 3591 3592 return self.api_client.call_api(resource_path, 'GET', 3593 path_params, 3594 query_params, 3595 header_params, 3596 body=body_params, 3597 post_params=form_params, 3598 files=local_var_files, 3599 response_type='BrandResourcesList', 3600 auth_settings=auth_settings, 3601 callback=params.get('callback'), 3602 _return_http_data_only=params.get('_return_http_data_only'), 3603 _preload_content=params.get('_preload_content', True), 3604 _request_timeout=params.get('_request_timeout'), 3605 collection_formats=collection_formats) 3606 3607 def get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs): 3608 """ 3609 Returns the specified branding resource file. 3610 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**). 3611 This method makes a synchronous HTTP request by default. To make an 3612 asynchronous HTTP request, please define a `callback` function 3613 to be invoked when receiving the response. 3614 >>> def callback_function(response): 3615 >>> pprint(response) 3616 >>> 3617 >>> thread = api.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, callback=callback_function) 3618 3619 :param callback function: The callback function 3620 for asynchronous request. (optional) 3621 :param str account_id: The external account number (int) or account ID Guid. (required) 3622 :param str brand_id: The unique identifier of a brand. (required) 3623 :param str resource_content_type: (required) 3624 :param str langcode: 3625 :param str return_master: 3626 :return: None 3627 If the method is called asynchronously, 3628 returns the request thread. 3629 """ 3630 kwargs['_return_http_data_only'] = True 3631 if kwargs.get('callback'): 3632 return self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3633 else: 3634 (data) = self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3635 return data 3636 3637 def get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs): 3638 """ 3639 Returns the specified branding resource file. 3640 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**). 3641 This method makes a synchronous HTTP request by default. To make an 3642 asynchronous HTTP request, please define a `callback` function 3643 to be invoked when receiving the response. 3644 >>> def callback_function(response): 3645 >>> pprint(response) 3646 >>> 3647 >>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function) 3648 3649 :param callback function: The callback function 3650 for asynchronous request. (optional) 3651 :param str account_id: The external account number (int) or account ID Guid. (required) 3652 :param str brand_id: The unique identifier of a brand. (required) 3653 :param str resource_content_type: (required) 3654 :param str langcode: 3655 :param str return_master: 3656 :return: None 3657 If the method is called asynchronously, 3658 returns the request thread. 3659 """ 3660 3661 all_params = ['account_id', 'brand_id', 'resource_content_type', 'langcode', 'return_master'] 3662 all_params.append('callback') 3663 all_params.append('_return_http_data_only') 3664 all_params.append('_preload_content') 3665 all_params.append('_request_timeout') 3666 3667 params = locals() 3668 for key, val in iteritems(params['kwargs']): 3669 if key not in all_params: 3670 raise TypeError( 3671 "Got an unexpected keyword argument '%s'" 3672 " to method get_brand_resources_by_content_type" % key 3673 ) 3674 params[key] = val 3675 del params['kwargs'] 3676 # verify the required parameter 'account_id' is set 3677 if ('account_id' not in params) or (params['account_id'] is None): 3678 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources_by_content_type`") 3679 # verify the required parameter 'brand_id' is set 3680 if ('brand_id' not in params) or (params['brand_id'] is None): 3681 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources_by_content_type`") 3682 # verify the required parameter 'resource_content_type' is set 3683 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 3684 raise ValueError("Missing the required parameter `resource_content_type` when calling `get_brand_resources_by_content_type`") 3685 3686 3687 collection_formats = {} 3688 3689 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 3690 path_params = {} 3691 if 'account_id' in params: 3692 path_params['accountId'] = params['account_id'] 3693 if 'brand_id' in params: 3694 path_params['brandId'] = params['brand_id'] 3695 if 'resource_content_type' in params: 3696 path_params['resourceContentType'] = params['resource_content_type'] 3697 3698 query_params = {} 3699 if 'langcode' in params: 3700 query_params['langcode'] = params['langcode'] 3701 if 'return_master' in params: 3702 query_params['return_master'] = params['return_master'] 3703 3704 header_params = {} 3705 3706 form_params = [] 3707 local_var_files = {} 3708 3709 body_params = None 3710 # HTTP header `Accept` 3711 header_params['Accept'] = self.api_client.\ 3712 select_header_accept(['application/json']) 3713 3714 # Authentication setting 3715 auth_settings = [] 3716 3717 return self.api_client.call_api(resource_path, 'GET', 3718 path_params, 3719 query_params, 3720 header_params, 3721 body=body_params, 3722 post_params=form_params, 3723 files=local_var_files, 3724 response_type=None, 3725 auth_settings=auth_settings, 3726 callback=params.get('callback'), 3727 _return_http_data_only=params.get('_return_http_data_only'), 3728 _preload_content=params.get('_preload_content', True), 3729 _request_timeout=params.get('_request_timeout'), 3730 collection_formats=collection_formats) 3731 3732 def get_consumer_disclosure(self, account_id, lang_code, **kwargs): 3733 """ 3734 Gets the Electronic Record and Signature Disclosure. 3735 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. 3736 This method makes a synchronous HTTP request by default. To make an 3737 asynchronous HTTP request, please define a `callback` function 3738 to be invoked when receiving the response. 3739 >>> def callback_function(response): 3740 >>> pprint(response) 3741 >>> 3742 >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function) 3743 3744 :param callback function: The callback function 3745 for asynchronous request. (optional) 3746 :param str account_id: The external account number (int) or account ID Guid. (required) 3747 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3748 :return: ConsumerDisclosure 3749 If the method is called asynchronously, 3750 returns the request thread. 3751 """ 3752 kwargs['_return_http_data_only'] = True 3753 if kwargs.get('callback'): 3754 return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3755 else: 3756 (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3757 return data 3758 3759 def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 3760 """ 3761 Gets the Electronic Record and Signature Disclosure. 3762 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. 3763 This method makes a synchronous HTTP request by default. To make an 3764 asynchronous HTTP request, please define a `callback` function 3765 to be invoked when receiving the response. 3766 >>> def callback_function(response): 3767 >>> pprint(response) 3768 >>> 3769 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 3770 3771 :param callback function: The callback function 3772 for asynchronous request. (optional) 3773 :param str account_id: The external account number (int) or account ID Guid. (required) 3774 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3775 :return: ConsumerDisclosure 3776 If the method is called asynchronously, 3777 returns the request thread. 3778 """ 3779 3780 all_params = ['account_id', 'lang_code'] 3781 all_params.append('callback') 3782 all_params.append('_return_http_data_only') 3783 all_params.append('_preload_content') 3784 all_params.append('_request_timeout') 3785 3786 params = locals() 3787 for key, val in iteritems(params['kwargs']): 3788 if key not in all_params: 3789 raise TypeError( 3790 "Got an unexpected keyword argument '%s'" 3791 " to method get_consumer_disclosure" % key 3792 ) 3793 params[key] = val 3794 del params['kwargs'] 3795 # verify the required parameter 'account_id' is set 3796 if ('account_id' not in params) or (params['account_id'] is None): 3797 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 3798 # verify the required parameter 'lang_code' is set 3799 if ('lang_code' not in params) or (params['lang_code'] is None): 3800 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 3801 3802 3803 collection_formats = {} 3804 3805 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 3806 path_params = {} 3807 if 'account_id' in params: 3808 path_params['accountId'] = params['account_id'] 3809 if 'lang_code' in params: 3810 path_params['langCode'] = params['lang_code'] 3811 3812 query_params = {} 3813 3814 header_params = {} 3815 3816 form_params = [] 3817 local_var_files = {} 3818 3819 body_params = None 3820 # HTTP header `Accept` 3821 header_params['Accept'] = self.api_client.\ 3822 select_header_accept(['application/json']) 3823 3824 # Authentication setting 3825 auth_settings = [] 3826 3827 return self.api_client.call_api(resource_path, 'GET', 3828 path_params, 3829 query_params, 3830 header_params, 3831 body=body_params, 3832 post_params=form_params, 3833 files=local_var_files, 3834 response_type='ConsumerDisclosure', 3835 auth_settings=auth_settings, 3836 callback=params.get('callback'), 3837 _return_http_data_only=params.get('_return_http_data_only'), 3838 _preload_content=params.get('_preload_content', True), 3839 _request_timeout=params.get('_request_timeout'), 3840 collection_formats=collection_formats) 3841 3842 def get_consumer_disclosure_default(self, account_id, **kwargs): 3843 """ 3844 Gets the Electronic Record and Signature Disclosure for the account. 3845 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. 3846 This method makes a synchronous HTTP request by default. To make an 3847 asynchronous HTTP request, please define a `callback` function 3848 to be invoked when receiving the response. 3849 >>> def callback_function(response): 3850 >>> pprint(response) 3851 >>> 3852 >>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function) 3853 3854 :param callback function: The callback function 3855 for asynchronous request. (optional) 3856 :param str account_id: The external account number (int) or account ID Guid. (required) 3857 :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. 3858 :return: ConsumerDisclosure 3859 If the method is called asynchronously, 3860 returns the request thread. 3861 """ 3862 kwargs['_return_http_data_only'] = True 3863 if kwargs.get('callback'): 3864 return self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3865 else: 3866 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3867 return data 3868 3869 def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs): 3870 """ 3871 Gets the Electronic Record and Signature Disclosure for the account. 3872 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. 3873 This method makes a synchronous HTTP request by default. To make an 3874 asynchronous HTTP request, please define a `callback` function 3875 to be invoked when receiving the response. 3876 >>> def callback_function(response): 3877 >>> pprint(response) 3878 >>> 3879 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function) 3880 3881 :param callback function: The callback function 3882 for asynchronous request. (optional) 3883 :param str account_id: The external account number (int) or account ID Guid. (required) 3884 :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. 3885 :return: ConsumerDisclosure 3886 If the method is called asynchronously, 3887 returns the request thread. 3888 """ 3889 3890 all_params = ['account_id', 'lang_code'] 3891 all_params.append('callback') 3892 all_params.append('_return_http_data_only') 3893 all_params.append('_preload_content') 3894 all_params.append('_request_timeout') 3895 3896 params = locals() 3897 for key, val in iteritems(params['kwargs']): 3898 if key not in all_params: 3899 raise TypeError( 3900 "Got an unexpected keyword argument '%s'" 3901 " to method get_consumer_disclosure_default" % key 3902 ) 3903 params[key] = val 3904 del params['kwargs'] 3905 # verify the required parameter 'account_id' is set 3906 if ('account_id' not in params) or (params['account_id'] is None): 3907 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 3908 3909 3910 collection_formats = {} 3911 3912 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json') 3913 path_params = {} 3914 if 'account_id' in params: 3915 path_params['accountId'] = params['account_id'] 3916 3917 query_params = {} 3918 if 'lang_code' in params: 3919 query_params['langCode'] = params['lang_code'] 3920 3921 header_params = {} 3922 3923 form_params = [] 3924 local_var_files = {} 3925 3926 body_params = None 3927 # HTTP header `Accept` 3928 header_params['Accept'] = self.api_client.\ 3929 select_header_accept(['application/json']) 3930 3931 # Authentication setting 3932 auth_settings = [] 3933 3934 return self.api_client.call_api(resource_path, 'GET', 3935 path_params, 3936 query_params, 3937 header_params, 3938 body=body_params, 3939 post_params=form_params, 3940 files=local_var_files, 3941 response_type='ConsumerDisclosure', 3942 auth_settings=auth_settings, 3943 callback=params.get('callback'), 3944 _return_http_data_only=params.get('_return_http_data_only'), 3945 _preload_content=params.get('_preload_content', True), 3946 _request_timeout=params.get('_request_timeout'), 3947 collection_formats=collection_formats) 3948 3949 def get_e_note_configuration(self, account_id, **kwargs): 3950 """ 3951 Returns the configuration information for the eNote eOriginal integration. 3952 3953 This method makes a synchronous HTTP request by default. To make an 3954 asynchronous HTTP request, please define a `callback` function 3955 to be invoked when receiving the response. 3956 >>> def callback_function(response): 3957 >>> pprint(response) 3958 >>> 3959 >>> thread = api.get_e_note_configuration(account_id, callback=callback_function) 3960 3961 :param callback function: The callback function 3962 for asynchronous request. (optional) 3963 :param str account_id: The external account number (int) or account ID Guid. (required) 3964 :return: ENoteConfiguration 3965 If the method is called asynchronously, 3966 returns the request thread. 3967 """ 3968 kwargs['_return_http_data_only'] = True 3969 if kwargs.get('callback'): 3970 return self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3971 else: 3972 (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3973 return data 3974 3975 def get_e_note_configuration_with_http_info(self, account_id, **kwargs): 3976 """ 3977 Returns the configuration information for the eNote eOriginal integration. 3978 3979 This method makes a synchronous HTTP request by default. To make an 3980 asynchronous HTTP request, please define a `callback` function 3981 to be invoked when receiving the response. 3982 >>> def callback_function(response): 3983 >>> pprint(response) 3984 >>> 3985 >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function) 3986 3987 :param callback function: The callback function 3988 for asynchronous request. (optional) 3989 :param str account_id: The external account number (int) or account ID Guid. (required) 3990 :return: ENoteConfiguration 3991 If the method is called asynchronously, 3992 returns the request thread. 3993 """ 3994 3995 all_params = ['account_id'] 3996 all_params.append('callback') 3997 all_params.append('_return_http_data_only') 3998 all_params.append('_preload_content') 3999 all_params.append('_request_timeout') 4000 4001 params = locals() 4002 for key, val in iteritems(params['kwargs']): 4003 if key not in all_params: 4004 raise TypeError( 4005 "Got an unexpected keyword argument '%s'" 4006 " to method get_e_note_configuration" % key 4007 ) 4008 params[key] = val 4009 del params['kwargs'] 4010 # verify the required parameter 'account_id' is set 4011 if ('account_id' not in params) or (params['account_id'] is None): 4012 raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`") 4013 4014 4015 collection_formats = {} 4016 4017 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 4018 path_params = {} 4019 if 'account_id' in params: 4020 path_params['accountId'] = params['account_id'] 4021 4022 query_params = {} 4023 4024 header_params = {} 4025 4026 form_params = [] 4027 local_var_files = {} 4028 4029 body_params = None 4030 # HTTP header `Accept` 4031 header_params['Accept'] = self.api_client.\ 4032 select_header_accept(['application/json']) 4033 4034 # Authentication setting 4035 auth_settings = [] 4036 4037 return self.api_client.call_api(resource_path, 'GET', 4038 path_params, 4039 query_params, 4040 header_params, 4041 body=body_params, 4042 post_params=form_params, 4043 files=local_var_files, 4044 response_type='ENoteConfiguration', 4045 auth_settings=auth_settings, 4046 callback=params.get('callback'), 4047 _return_http_data_only=params.get('_return_http_data_only'), 4048 _preload_content=params.get('_preload_content', True), 4049 _request_timeout=params.get('_request_timeout'), 4050 collection_formats=collection_formats) 4051 4052 def get_envelope_purge_configuration(self, account_id, **kwargs): 4053 """ 4054 Select envelope purge configuration. 4055 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. 4056 This method makes a synchronous HTTP request by default. To make an 4057 asynchronous HTTP request, please define a `callback` function 4058 to be invoked when receiving the response. 4059 >>> def callback_function(response): 4060 >>> pprint(response) 4061 >>> 4062 >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function) 4063 4064 :param callback function: The callback function 4065 for asynchronous request. (optional) 4066 :param str account_id: The external account number (int) or account ID Guid. (required) 4067 :return: EnvelopePurgeConfiguration 4068 If the method is called asynchronously, 4069 returns the request thread. 4070 """ 4071 kwargs['_return_http_data_only'] = True 4072 if kwargs.get('callback'): 4073 return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4074 else: 4075 (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4076 return data 4077 4078 def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 4079 """ 4080 Select envelope purge configuration. 4081 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. 4082 This method makes a synchronous HTTP request by default. To make an 4083 asynchronous HTTP request, please define a `callback` function 4084 to be invoked when receiving the response. 4085 >>> def callback_function(response): 4086 >>> pprint(response) 4087 >>> 4088 >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 4089 4090 :param callback function: The callback function 4091 for asynchronous request. (optional) 4092 :param str account_id: The external account number (int) or account ID Guid. (required) 4093 :return: EnvelopePurgeConfiguration 4094 If the method is called asynchronously, 4095 returns the request thread. 4096 """ 4097 4098 all_params = ['account_id'] 4099 all_params.append('callback') 4100 all_params.append('_return_http_data_only') 4101 all_params.append('_preload_content') 4102 all_params.append('_request_timeout') 4103 4104 params = locals() 4105 for key, val in iteritems(params['kwargs']): 4106 if key not in all_params: 4107 raise TypeError( 4108 "Got an unexpected keyword argument '%s'" 4109 " to method get_envelope_purge_configuration" % key 4110 ) 4111 params[key] = val 4112 del params['kwargs'] 4113 # verify the required parameter 'account_id' is set 4114 if ('account_id' not in params) or (params['account_id'] is None): 4115 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`") 4116 4117 4118 collection_formats = {} 4119 4120 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 4121 path_params = {} 4122 if 'account_id' in params: 4123 path_params['accountId'] = params['account_id'] 4124 4125 query_params = {} 4126 4127 header_params = {} 4128 4129 form_params = [] 4130 local_var_files = {} 4131 4132 body_params = None 4133 # HTTP header `Accept` 4134 header_params['Accept'] = self.api_client.\ 4135 select_header_accept(['application/json']) 4136 4137 # Authentication setting 4138 auth_settings = [] 4139 4140 return self.api_client.call_api(resource_path, 'GET', 4141 path_params, 4142 query_params, 4143 header_params, 4144 body=body_params, 4145 post_params=form_params, 4146 files=local_var_files, 4147 response_type='EnvelopePurgeConfiguration', 4148 auth_settings=auth_settings, 4149 callback=params.get('callback'), 4150 _return_http_data_only=params.get('_return_http_data_only'), 4151 _preload_content=params.get('_preload_content', True), 4152 _request_timeout=params.get('_request_timeout'), 4153 collection_formats=collection_formats) 4154 4155 def get_favorite_templates(self, account_id, **kwargs): 4156 """ 4157 Retrieves the list of favorited templates for this caller 4158 4159 This method makes a synchronous HTTP request by default. To make an 4160 asynchronous HTTP request, please define a `callback` function 4161 to be invoked when receiving the response. 4162 >>> def callback_function(response): 4163 >>> pprint(response) 4164 >>> 4165 >>> thread = api.get_favorite_templates(account_id, callback=callback_function) 4166 4167 :param callback function: The callback function 4168 for asynchronous request. (optional) 4169 :param str account_id: The external account number (int) or account ID Guid. (required) 4170 :return: FavoriteTemplatesInfo 4171 If the method is called asynchronously, 4172 returns the request thread. 4173 """ 4174 kwargs['_return_http_data_only'] = True 4175 if kwargs.get('callback'): 4176 return self.get_favorite_templates_with_http_info(account_id, **kwargs) 4177 else: 4178 (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs) 4179 return data 4180 4181 def get_favorite_templates_with_http_info(self, account_id, **kwargs): 4182 """ 4183 Retrieves the list of favorited templates for this caller 4184 4185 This method makes a synchronous HTTP request by default. To make an 4186 asynchronous HTTP request, please define a `callback` function 4187 to be invoked when receiving the response. 4188 >>> def callback_function(response): 4189 >>> pprint(response) 4190 >>> 4191 >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function) 4192 4193 :param callback function: The callback function 4194 for asynchronous request. (optional) 4195 :param str account_id: The external account number (int) or account ID Guid. (required) 4196 :return: FavoriteTemplatesInfo 4197 If the method is called asynchronously, 4198 returns the request thread. 4199 """ 4200 4201 all_params = ['account_id'] 4202 all_params.append('callback') 4203 all_params.append('_return_http_data_only') 4204 all_params.append('_preload_content') 4205 all_params.append('_request_timeout') 4206 4207 params = locals() 4208 for key, val in iteritems(params['kwargs']): 4209 if key not in all_params: 4210 raise TypeError( 4211 "Got an unexpected keyword argument '%s'" 4212 " to method get_favorite_templates" % key 4213 ) 4214 params[key] = val 4215 del params['kwargs'] 4216 # verify the required parameter 'account_id' is set 4217 if ('account_id' not in params) or (params['account_id'] is None): 4218 raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`") 4219 4220 4221 collection_formats = {} 4222 4223 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 4224 path_params = {} 4225 if 'account_id' in params: 4226 path_params['accountId'] = params['account_id'] 4227 4228 query_params = {} 4229 4230 header_params = {} 4231 4232 form_params = [] 4233 local_var_files = {} 4234 4235 body_params = None 4236 # HTTP header `Accept` 4237 header_params['Accept'] = self.api_client.\ 4238 select_header_accept(['application/json']) 4239 4240 # Authentication setting 4241 auth_settings = [] 4242 4243 return self.api_client.call_api(resource_path, 'GET', 4244 path_params, 4245 query_params, 4246 header_params, 4247 body=body_params, 4248 post_params=form_params, 4249 files=local_var_files, 4250 response_type='FavoriteTemplatesInfo', 4251 auth_settings=auth_settings, 4252 callback=params.get('callback'), 4253 _return_http_data_only=params.get('_return_http_data_only'), 4254 _preload_content=params.get('_preload_content', True), 4255 _request_timeout=params.get('_request_timeout'), 4256 collection_formats=collection_formats) 4257 4258 def get_notification_defaults(self, account_id, **kwargs): 4259 """ 4260 Returns default user level settings for a specified account 4261 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4262 This method makes a synchronous HTTP request by default. To make an 4263 asynchronous HTTP request, please define a `callback` function 4264 to be invoked when receiving the response. 4265 >>> def callback_function(response): 4266 >>> pprint(response) 4267 >>> 4268 >>> thread = api.get_notification_defaults(account_id, callback=callback_function) 4269 4270 :param callback function: The callback function 4271 for asynchronous request. (optional) 4272 :param str account_id: The external account number (int) or account ID Guid. (required) 4273 :return: NotificationDefaults 4274 If the method is called asynchronously, 4275 returns the request thread. 4276 """ 4277 kwargs['_return_http_data_only'] = True 4278 if kwargs.get('callback'): 4279 return self.get_notification_defaults_with_http_info(account_id, **kwargs) 4280 else: 4281 (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs) 4282 return data 4283 4284 def get_notification_defaults_with_http_info(self, account_id, **kwargs): 4285 """ 4286 Returns default user level settings for a specified account 4287 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4288 This method makes a synchronous HTTP request by default. To make an 4289 asynchronous HTTP request, please define a `callback` function 4290 to be invoked when receiving the response. 4291 >>> def callback_function(response): 4292 >>> pprint(response) 4293 >>> 4294 >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function) 4295 4296 :param callback function: The callback function 4297 for asynchronous request. (optional) 4298 :param str account_id: The external account number (int) or account ID Guid. (required) 4299 :return: NotificationDefaults 4300 If the method is called asynchronously, 4301 returns the request thread. 4302 """ 4303 4304 all_params = ['account_id'] 4305 all_params.append('callback') 4306 all_params.append('_return_http_data_only') 4307 all_params.append('_preload_content') 4308 all_params.append('_request_timeout') 4309 4310 params = locals() 4311 for key, val in iteritems(params['kwargs']): 4312 if key not in all_params: 4313 raise TypeError( 4314 "Got an unexpected keyword argument '%s'" 4315 " to method get_notification_defaults" % key 4316 ) 4317 params[key] = val 4318 del params['kwargs'] 4319 # verify the required parameter 'account_id' is set 4320 if ('account_id' not in params) or (params['account_id'] is None): 4321 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`") 4322 4323 4324 collection_formats = {} 4325 4326 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 4327 path_params = {} 4328 if 'account_id' in params: 4329 path_params['accountId'] = params['account_id'] 4330 4331 query_params = {} 4332 4333 header_params = {} 4334 4335 form_params = [] 4336 local_var_files = {} 4337 4338 body_params = None 4339 # HTTP header `Accept` 4340 header_params['Accept'] = self.api_client.\ 4341 select_header_accept(['application/json']) 4342 4343 # Authentication setting 4344 auth_settings = [] 4345 4346 return self.api_client.call_api(resource_path, 'GET', 4347 path_params, 4348 query_params, 4349 header_params, 4350 body=body_params, 4351 post_params=form_params, 4352 files=local_var_files, 4353 response_type='NotificationDefaults', 4354 auth_settings=auth_settings, 4355 callback=params.get('callback'), 4356 _return_http_data_only=params.get('_return_http_data_only'), 4357 _preload_content=params.get('_preload_content', True), 4358 _request_timeout=params.get('_request_timeout'), 4359 collection_formats=collection_formats) 4360 4361 def get_password_rules(self, account_id, **kwargs): 4362 """ 4363 Get the password rules 4364 This method retrieves the password rules for an account. 4365 This method makes a synchronous HTTP request by default. To make an 4366 asynchronous HTTP request, please define a `callback` function 4367 to be invoked when receiving the response. 4368 >>> def callback_function(response): 4369 >>> pprint(response) 4370 >>> 4371 >>> thread = api.get_password_rules(account_id, callback=callback_function) 4372 4373 :param callback function: The callback function 4374 for asynchronous request. (optional) 4375 :param str account_id: The external account number (int) or account ID Guid. (required) 4376 :return: AccountPasswordRules 4377 If the method is called asynchronously, 4378 returns the request thread. 4379 """ 4380 kwargs['_return_http_data_only'] = True 4381 if kwargs.get('callback'): 4382 return self.get_password_rules_with_http_info(account_id, **kwargs) 4383 else: 4384 (data) = self.get_password_rules_with_http_info(account_id, **kwargs) 4385 return data 4386 4387 def get_password_rules_with_http_info(self, account_id, **kwargs): 4388 """ 4389 Get the password rules 4390 This method retrieves the password rules for an account. 4391 This method makes a synchronous HTTP request by default. To make an 4392 asynchronous HTTP request, please define a `callback` function 4393 to be invoked when receiving the response. 4394 >>> def callback_function(response): 4395 >>> pprint(response) 4396 >>> 4397 >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function) 4398 4399 :param callback function: The callback function 4400 for asynchronous request. (optional) 4401 :param str account_id: The external account number (int) or account ID Guid. (required) 4402 :return: AccountPasswordRules 4403 If the method is called asynchronously, 4404 returns the request thread. 4405 """ 4406 4407 all_params = ['account_id'] 4408 all_params.append('callback') 4409 all_params.append('_return_http_data_only') 4410 all_params.append('_preload_content') 4411 all_params.append('_request_timeout') 4412 4413 params = locals() 4414 for key, val in iteritems(params['kwargs']): 4415 if key not in all_params: 4416 raise TypeError( 4417 "Got an unexpected keyword argument '%s'" 4418 " to method get_password_rules" % key 4419 ) 4420 params[key] = val 4421 del params['kwargs'] 4422 # verify the required parameter 'account_id' is set 4423 if ('account_id' not in params) or (params['account_id'] is None): 4424 raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`") 4425 4426 4427 collection_formats = {} 4428 4429 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 4430 path_params = {} 4431 if 'account_id' in params: 4432 path_params['accountId'] = params['account_id'] 4433 4434 query_params = {} 4435 4436 header_params = {} 4437 4438 form_params = [] 4439 local_var_files = {} 4440 4441 body_params = None 4442 # HTTP header `Accept` 4443 header_params['Accept'] = self.api_client.\ 4444 select_header_accept(['application/json']) 4445 4446 # Authentication setting 4447 auth_settings = [] 4448 4449 return self.api_client.call_api(resource_path, 'GET', 4450 path_params, 4451 query_params, 4452 header_params, 4453 body=body_params, 4454 post_params=form_params, 4455 files=local_var_files, 4456 response_type='AccountPasswordRules', 4457 auth_settings=auth_settings, 4458 callback=params.get('callback'), 4459 _return_http_data_only=params.get('_return_http_data_only'), 4460 _preload_content=params.get('_preload_content', True), 4461 _request_timeout=params.get('_request_timeout'), 4462 collection_formats=collection_formats) 4463 4464 def get_password_rules_0(self, **kwargs): 4465 """ 4466 Get membership account password rules 4467 4468 This method makes a synchronous HTTP request by default. To make an 4469 asynchronous HTTP request, please define a `callback` function 4470 to be invoked when receiving the response. 4471 >>> def callback_function(response): 4472 >>> pprint(response) 4473 >>> 4474 >>> thread = api.get_password_rules_0(callback=callback_function) 4475 4476 :param callback function: The callback function 4477 for asynchronous request. (optional) 4478 :return: UserPasswordRules 4479 If the method is called asynchronously, 4480 returns the request thread. 4481 """ 4482 kwargs['_return_http_data_only'] = True 4483 if kwargs.get('callback'): 4484 return self.get_password_rules_0_with_http_info(**kwargs) 4485 else: 4486 (data) = self.get_password_rules_0_with_http_info(**kwargs) 4487 return data 4488 4489 def get_password_rules_0_with_http_info(self, **kwargs): 4490 """ 4491 Get membership account password rules 4492 4493 This method makes a synchronous HTTP request by default. To make an 4494 asynchronous HTTP request, please define a `callback` function 4495 to be invoked when receiving the response. 4496 >>> def callback_function(response): 4497 >>> pprint(response) 4498 >>> 4499 >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function) 4500 4501 :param callback function: The callback function 4502 for asynchronous request. (optional) 4503 :return: UserPasswordRules 4504 If the method is called asynchronously, 4505 returns the request thread. 4506 """ 4507 4508 all_params = [] 4509 all_params.append('callback') 4510 all_params.append('_return_http_data_only') 4511 all_params.append('_preload_content') 4512 all_params.append('_request_timeout') 4513 4514 params = locals() 4515 for key, val in iteritems(params['kwargs']): 4516 if key not in all_params: 4517 raise TypeError( 4518 "Got an unexpected keyword argument '%s'" 4519 " to method get_password_rules_0" % key 4520 ) 4521 params[key] = val 4522 del params['kwargs'] 4523 4524 collection_formats = {} 4525 4526 resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json') 4527 path_params = {} 4528 4529 query_params = {} 4530 4531 header_params = {} 4532 4533 form_params = [] 4534 local_var_files = {} 4535 4536 body_params = None 4537 # HTTP header `Accept` 4538 header_params['Accept'] = self.api_client.\ 4539 select_header_accept(['application/json']) 4540 4541 # Authentication setting 4542 auth_settings = [] 4543 4544 return self.api_client.call_api(resource_path, 'GET', 4545 path_params, 4546 query_params, 4547 header_params, 4548 body=body_params, 4549 post_params=form_params, 4550 files=local_var_files, 4551 response_type='UserPasswordRules', 4552 auth_settings=auth_settings, 4553 callback=params.get('callback'), 4554 _return_http_data_only=params.get('_return_http_data_only'), 4555 _preload_content=params.get('_preload_content', True), 4556 _request_timeout=params.get('_request_timeout'), 4557 collection_formats=collection_formats) 4558 4559 def get_permission_profile(self, account_id, permission_profile_id, **kwargs): 4560 """ 4561 Returns a permissions profile in the specified account. 4562 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/) 4563 This method makes a synchronous HTTP request by default. To make an 4564 asynchronous HTTP request, please define a `callback` function 4565 to be invoked when receiving the response. 4566 >>> def callback_function(response): 4567 >>> pprint(response) 4568 >>> 4569 >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function) 4570 4571 :param callback function: The callback function 4572 for asynchronous request. (optional) 4573 :param str account_id: The external account number (int) or account ID Guid. (required) 4574 :param str permission_profile_id: (required) 4575 :param str include: 4576 :return: PermissionProfile 4577 If the method is called asynchronously, 4578 returns the request thread. 4579 """ 4580 kwargs['_return_http_data_only'] = True 4581 if kwargs.get('callback'): 4582 return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4583 else: 4584 (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4585 return data 4586 4587 def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 4588 """ 4589 Returns a permissions profile in the specified account. 4590 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/) 4591 This method makes a synchronous HTTP request by default. To make an 4592 asynchronous HTTP request, please define a `callback` function 4593 to be invoked when receiving the response. 4594 >>> def callback_function(response): 4595 >>> pprint(response) 4596 >>> 4597 >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 4598 4599 :param callback function: The callback function 4600 for asynchronous request. (optional) 4601 :param str account_id: The external account number (int) or account ID Guid. (required) 4602 :param str permission_profile_id: (required) 4603 :param str include: 4604 :return: PermissionProfile 4605 If the method is called asynchronously, 4606 returns the request thread. 4607 """ 4608 4609 all_params = ['account_id', 'permission_profile_id', 'include'] 4610 all_params.append('callback') 4611 all_params.append('_return_http_data_only') 4612 all_params.append('_preload_content') 4613 all_params.append('_request_timeout') 4614 4615 params = locals() 4616 for key, val in iteritems(params['kwargs']): 4617 if key not in all_params: 4618 raise TypeError( 4619 "Got an unexpected keyword argument '%s'" 4620 " to method get_permission_profile" % key 4621 ) 4622 params[key] = val 4623 del params['kwargs'] 4624 # verify the required parameter 'account_id' is set 4625 if ('account_id' not in params) or (params['account_id'] is None): 4626 raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`") 4627 # verify the required parameter 'permission_profile_id' is set 4628 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 4629 raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`") 4630 4631 4632 collection_formats = {} 4633 4634 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 4635 path_params = {} 4636 if 'account_id' in params: 4637 path_params['accountId'] = params['account_id'] 4638 if 'permission_profile_id' in params: 4639 path_params['permissionProfileId'] = params['permission_profile_id'] 4640 4641 query_params = {} 4642 if 'include' in params: 4643 query_params['include'] = params['include'] 4644 4645 header_params = {} 4646 4647 form_params = [] 4648 local_var_files = {} 4649 4650 body_params = None 4651 # HTTP header `Accept` 4652 header_params['Accept'] = self.api_client.\ 4653 select_header_accept(['application/json']) 4654 4655 # Authentication setting 4656 auth_settings = [] 4657 4658 return self.api_client.call_api(resource_path, 'GET', 4659 path_params, 4660 query_params, 4661 header_params, 4662 body=body_params, 4663 post_params=form_params, 4664 files=local_var_files, 4665 response_type='PermissionProfile', 4666 auth_settings=auth_settings, 4667 callback=params.get('callback'), 4668 _return_http_data_only=params.get('_return_http_data_only'), 4669 _preload_content=params.get('_preload_content', True), 4670 _request_timeout=params.get('_request_timeout'), 4671 collection_formats=collection_formats) 4672 4673 def get_principal_user_authorizations(self, account_id, user_id, **kwargs): 4674 """ 4675 Returns the principal user authorizations 4676 This method makes a synchronous HTTP request by default. To make an 4677 asynchronous HTTP request, please define a `callback` function 4678 to be invoked when receiving the response. 4679 >>> def callback_function(response): 4680 >>> pprint(response) 4681 >>> 4682 >>> thread = api.get_principal_user_authorizations(account_id, user_id, callback=callback_function) 4683 4684 :param callback function: The callback function 4685 for asynchronous request. (optional) 4686 :param str account_id: The external account number (int) or account ID Guid. (required) 4687 :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) 4688 :param str active_only: 4689 :param str count: 4690 :param str email_substring: Part (substring) of email we are searching for. 4691 :param str include_closed_users: 4692 :param str permissions: 4693 :param str start_position: 4694 :param str user_name_substring: 4695 :return: UserAuthorizations 4696 If the method is called asynchronously, 4697 returns the request thread. 4698 """ 4699 kwargs['_return_http_data_only'] = True 4700 if kwargs.get('callback'): 4701 return self.get_principal_user_authorizations_with_http_info(account_id, user_id, **kwargs) 4702 else: 4703 (data) = self.get_principal_user_authorizations_with_http_info(account_id, user_id, **kwargs) 4704 return data 4705 4706 def get_principal_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 4707 """ 4708 Returns the principal user authorizations 4709 This method makes a synchronous HTTP request by default. To make an 4710 asynchronous HTTP request, please define a `callback` function 4711 to be invoked when receiving the response. 4712 >>> def callback_function(response): 4713 >>> pprint(response) 4714 >>> 4715 >>> thread = api.get_principal_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 4716 4717 :param callback function: The callback function 4718 for asynchronous request. (optional) 4719 :param str account_id: The external account number (int) or account ID Guid. (required) 4720 :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) 4721 :param str active_only: 4722 :param str count: 4723 :param str email_substring: Part (substring) of email we are searching for. 4724 :param str include_closed_users: 4725 :param str permissions: 4726 :param str start_position: 4727 :param str user_name_substring: 4728 :return: UserAuthorizations 4729 If the method is called asynchronously, 4730 returns the request thread. 4731 """ 4732 4733 all_params = ['account_id', 'user_id', 'active_only', 'count', 'email_substring', 'include_closed_users', 'permissions', 'start_position', 'user_name_substring'] 4734 all_params.append('callback') 4735 all_params.append('_return_http_data_only') 4736 all_params.append('_preload_content') 4737 all_params.append('_request_timeout') 4738 4739 params = locals() 4740 for key, val in iteritems(params['kwargs']): 4741 if key not in all_params: 4742 raise TypeError( 4743 "Got an unexpected keyword argument '%s'" 4744 " to method get_principal_user_authorizations" % key 4745 ) 4746 params[key] = val 4747 del params['kwargs'] 4748 # verify the required parameter 'account_id' is set 4749 if ('account_id' not in params) or (params['account_id'] is None): 4750 raise ValueError("Missing the required parameter `account_id` when calling `get_principal_user_authorizations`") 4751 # verify the required parameter 'user_id' is set 4752 if ('user_id' not in params) or (params['user_id'] is None): 4753 raise ValueError("Missing the required parameter `user_id` when calling `get_principal_user_authorizations`") 4754 4755 4756 collection_formats = {} 4757 4758 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations'.replace('{format}', 'json') 4759 path_params = {} 4760 if 'account_id' in params: 4761 path_params['accountId'] = params['account_id'] 4762 if 'user_id' in params: 4763 path_params['userId'] = params['user_id'] 4764 4765 query_params = {} 4766 if 'active_only' in params: 4767 query_params['active_only'] = params['active_only'] 4768 if 'count' in params: 4769 query_params['count'] = params['count'] 4770 if 'email_substring' in params: 4771 query_params['email_substring'] = params['email_substring'] 4772 if 'include_closed_users' in params: 4773 query_params['include_closed_users'] = params['include_closed_users'] 4774 if 'permissions' in params: 4775 query_params['permissions'] = params['permissions'] 4776 if 'start_position' in params: 4777 query_params['start_position'] = params['start_position'] 4778 if 'user_name_substring' in params: 4779 query_params['user_name_substring'] = params['user_name_substring'] 4780 4781 header_params = {} 4782 4783 form_params = [] 4784 local_var_files = {} 4785 4786 body_params = None 4787 # HTTP header `Accept` 4788 header_params['Accept'] = self.api_client.\ 4789 select_header_accept(['application/json']) 4790 4791 # Authentication setting 4792 auth_settings = [] 4793 4794 return self.api_client.call_api(resource_path, 'GET', 4795 path_params, 4796 query_params, 4797 header_params, 4798 body=body_params, 4799 post_params=form_params, 4800 files=local_var_files, 4801 response_type='UserAuthorizations', 4802 auth_settings=auth_settings, 4803 callback=params.get('callback'), 4804 _return_http_data_only=params.get('_return_http_data_only'), 4805 _preload_content=params.get('_preload_content', True), 4806 _request_timeout=params.get('_request_timeout'), 4807 collection_formats=collection_formats) 4808 4809 def get_provisioning(self, **kwargs): 4810 """ 4811 Retrieves the account provisioning information for the account. 4812 Retrieves the account provisioning information for the account. 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_provisioning(callback=callback_function) 4820 4821 :param callback function: The callback function 4822 for asynchronous request. (optional) 4823 :return: ProvisioningInformation 4824 If the method is called asynchronously, 4825 returns the request thread. 4826 """ 4827 kwargs['_return_http_data_only'] = True 4828 if kwargs.get('callback'): 4829 return self.get_provisioning_with_http_info(**kwargs) 4830 else: 4831 (data) = self.get_provisioning_with_http_info(**kwargs) 4832 return data 4833 4834 def get_provisioning_with_http_info(self, **kwargs): 4835 """ 4836 Retrieves the account provisioning information for the account. 4837 Retrieves the account provisioning information for the account. 4838 This method makes a synchronous HTTP request by default. To make an 4839 asynchronous HTTP request, please define a `callback` function 4840 to be invoked when receiving the response. 4841 >>> def callback_function(response): 4842 >>> pprint(response) 4843 >>> 4844 >>> thread = api.get_provisioning_with_http_info(callback=callback_function) 4845 4846 :param callback function: The callback function 4847 for asynchronous request. (optional) 4848 :return: ProvisioningInformation 4849 If the method is called asynchronously, 4850 returns the request thread. 4851 """ 4852 4853 all_params = [] 4854 all_params.append('callback') 4855 all_params.append('_return_http_data_only') 4856 all_params.append('_preload_content') 4857 all_params.append('_request_timeout') 4858 4859 params = locals() 4860 for key, val in iteritems(params['kwargs']): 4861 if key not in all_params: 4862 raise TypeError( 4863 "Got an unexpected keyword argument '%s'" 4864 " to method get_provisioning" % key 4865 ) 4866 params[key] = val 4867 del params['kwargs'] 4868 4869 collection_formats = {} 4870 4871 resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json') 4872 path_params = {} 4873 4874 query_params = {} 4875 4876 header_params = {} 4877 4878 form_params = [] 4879 local_var_files = {} 4880 4881 body_params = None 4882 # HTTP header `Accept` 4883 header_params['Accept'] = self.api_client.\ 4884 select_header_accept(['application/json']) 4885 4886 # Authentication setting 4887 auth_settings = [] 4888 4889 return self.api_client.call_api(resource_path, 'GET', 4890 path_params, 4891 query_params, 4892 header_params, 4893 body=body_params, 4894 post_params=form_params, 4895 files=local_var_files, 4896 response_type='ProvisioningInformation', 4897 auth_settings=auth_settings, 4898 callback=params.get('callback'), 4899 _return_http_data_only=params.get('_return_http_data_only'), 4900 _preload_content=params.get('_preload_content', True), 4901 _request_timeout=params.get('_request_timeout'), 4902 collection_formats=collection_formats) 4903 4904 def get_supported_languages(self, account_id, **kwargs): 4905 """ 4906 Gets list of supported languages for recipient language setting. 4907 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). 4908 This method makes a synchronous HTTP request by default. To make an 4909 asynchronous HTTP request, please define a `callback` function 4910 to be invoked when receiving the response. 4911 >>> def callback_function(response): 4912 >>> pprint(response) 4913 >>> 4914 >>> thread = api.get_supported_languages(account_id, callback=callback_function) 4915 4916 :param callback function: The callback function 4917 for asynchronous request. (optional) 4918 :param str account_id: The external account number (int) or account ID Guid. (required) 4919 :return: SupportedLanguages 4920 If the method is called asynchronously, 4921 returns the request thread. 4922 """ 4923 kwargs['_return_http_data_only'] = True 4924 if kwargs.get('callback'): 4925 return self.get_supported_languages_with_http_info(account_id, **kwargs) 4926 else: 4927 (data) = self.get_supported_languages_with_http_info(account_id, **kwargs) 4928 return data 4929 4930 def get_supported_languages_with_http_info(self, account_id, **kwargs): 4931 """ 4932 Gets list of supported languages for recipient language setting. 4933 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). 4934 This method makes a synchronous HTTP request by default. To make an 4935 asynchronous HTTP request, please define a `callback` function 4936 to be invoked when receiving the response. 4937 >>> def callback_function(response): 4938 >>> pprint(response) 4939 >>> 4940 >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function) 4941 4942 :param callback function: The callback function 4943 for asynchronous request. (optional) 4944 :param str account_id: The external account number (int) or account ID Guid. (required) 4945 :return: SupportedLanguages 4946 If the method is called asynchronously, 4947 returns the request thread. 4948 """ 4949 4950 all_params = ['account_id'] 4951 all_params.append('callback') 4952 all_params.append('_return_http_data_only') 4953 all_params.append('_preload_content') 4954 all_params.append('_request_timeout') 4955 4956 params = locals() 4957 for key, val in iteritems(params['kwargs']): 4958 if key not in all_params: 4959 raise TypeError( 4960 "Got an unexpected keyword argument '%s'" 4961 " to method get_supported_languages" % key 4962 ) 4963 params[key] = val 4964 del params['kwargs'] 4965 # verify the required parameter 'account_id' is set 4966 if ('account_id' not in params) or (params['account_id'] is None): 4967 raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`") 4968 4969 4970 collection_formats = {} 4971 4972 resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json') 4973 path_params = {} 4974 if 'account_id' in params: 4975 path_params['accountId'] = params['account_id'] 4976 4977 query_params = {} 4978 4979 header_params = {} 4980 4981 form_params = [] 4982 local_var_files = {} 4983 4984 body_params = None 4985 # HTTP header `Accept` 4986 header_params['Accept'] = self.api_client.\ 4987 select_header_accept(['application/json']) 4988 4989 # Authentication setting 4990 auth_settings = [] 4991 4992 return self.api_client.call_api(resource_path, 'GET', 4993 path_params, 4994 query_params, 4995 header_params, 4996 body=body_params, 4997 post_params=form_params, 4998 files=local_var_files, 4999 response_type='SupportedLanguages', 5000 auth_settings=auth_settings, 5001 callback=params.get('callback'), 5002 _return_http_data_only=params.get('_return_http_data_only'), 5003 _preload_content=params.get('_preload_content', True), 5004 _request_timeout=params.get('_request_timeout'), 5005 collection_formats=collection_formats) 5006 5007 def get_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 5008 """ 5009 Returns the user authorization for a given authorization id 5010 This method makes a synchronous HTTP request by default. To make an 5011 asynchronous HTTP request, please define a `callback` function 5012 to be invoked when receiving the response. 5013 >>> def callback_function(response): 5014 >>> pprint(response) 5015 >>> 5016 >>> thread = api.get_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 5017 5018 :param callback function: The callback function 5019 for asynchronous request. (optional) 5020 :param str account_id: The external account number (int) or account ID Guid. (required) 5021 :param str authorization_id: (required) 5022 :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) 5023 :return: UserAuthorization 5024 If the method is called asynchronously, 5025 returns the request thread. 5026 """ 5027 kwargs['_return_http_data_only'] = True 5028 if kwargs.get('callback'): 5029 return self.get_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 5030 else: 5031 (data) = self.get_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 5032 return data 5033 5034 def get_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 5035 """ 5036 Returns the user authorization for a given authorization id 5037 This method makes a synchronous HTTP request by default. To make an 5038 asynchronous HTTP request, please define a `callback` function 5039 to be invoked when receiving the response. 5040 >>> def callback_function(response): 5041 >>> pprint(response) 5042 >>> 5043 >>> thread = api.get_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 5044 5045 :param callback function: The callback function 5046 for asynchronous request. (optional) 5047 :param str account_id: The external account number (int) or account ID Guid. (required) 5048 :param str authorization_id: (required) 5049 :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) 5050 :return: UserAuthorization 5051 If the method is called asynchronously, 5052 returns the request thread. 5053 """ 5054 5055 all_params = ['account_id', 'authorization_id', 'user_id'] 5056 all_params.append('callback') 5057 all_params.append('_return_http_data_only') 5058 all_params.append('_preload_content') 5059 all_params.append('_request_timeout') 5060 5061 params = locals() 5062 for key, val in iteritems(params['kwargs']): 5063 if key not in all_params: 5064 raise TypeError( 5065 "Got an unexpected keyword argument '%s'" 5066 " to method get_user_authorization" % key 5067 ) 5068 params[key] = val 5069 del params['kwargs'] 5070 # verify the required parameter 'account_id' is set 5071 if ('account_id' not in params) or (params['account_id'] is None): 5072 raise ValueError("Missing the required parameter `account_id` when calling `get_user_authorization`") 5073 # verify the required parameter 'authorization_id' is set 5074 if ('authorization_id' not in params) or (params['authorization_id'] is None): 5075 raise ValueError("Missing the required parameter `authorization_id` when calling `get_user_authorization`") 5076 # verify the required parameter 'user_id' is set 5077 if ('user_id' not in params) or (params['user_id'] is None): 5078 raise ValueError("Missing the required parameter `user_id` when calling `get_user_authorization`") 5079 5080 5081 collection_formats = {} 5082 5083 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 5084 path_params = {} 5085 if 'account_id' in params: 5086 path_params['accountId'] = params['account_id'] 5087 if 'authorization_id' in params: 5088 path_params['authorizationId'] = params['authorization_id'] 5089 if 'user_id' in params: 5090 path_params['userId'] = params['user_id'] 5091 5092 query_params = {} 5093 5094 header_params = {} 5095 5096 form_params = [] 5097 local_var_files = {} 5098 5099 body_params = None 5100 # HTTP header `Accept` 5101 header_params['Accept'] = self.api_client.\ 5102 select_header_accept(['application/json']) 5103 5104 # Authentication setting 5105 auth_settings = [] 5106 5107 return self.api_client.call_api(resource_path, 'GET', 5108 path_params, 5109 query_params, 5110 header_params, 5111 body=body_params, 5112 post_params=form_params, 5113 files=local_var_files, 5114 response_type='UserAuthorization', 5115 auth_settings=auth_settings, 5116 callback=params.get('callback'), 5117 _return_http_data_only=params.get('_return_http_data_only'), 5118 _preload_content=params.get('_preload_content', True), 5119 _request_timeout=params.get('_request_timeout'), 5120 collection_formats=collection_formats) 5121 5122 def get_watermark(self, account_id, **kwargs): 5123 """ 5124 Get watermark information. 5125 5126 This method makes a synchronous HTTP request by default. To make an 5127 asynchronous HTTP request, please define a `callback` function 5128 to be invoked when receiving the response. 5129 >>> def callback_function(response): 5130 >>> pprint(response) 5131 >>> 5132 >>> thread = api.get_watermark(account_id, callback=callback_function) 5133 5134 :param callback function: The callback function 5135 for asynchronous request. (optional) 5136 :param str account_id: The external account number (int) or account ID Guid. (required) 5137 :return: Watermark 5138 If the method is called asynchronously, 5139 returns the request thread. 5140 """ 5141 kwargs['_return_http_data_only'] = True 5142 if kwargs.get('callback'): 5143 return self.get_watermark_with_http_info(account_id, **kwargs) 5144 else: 5145 (data) = self.get_watermark_with_http_info(account_id, **kwargs) 5146 return data 5147 5148 def get_watermark_with_http_info(self, account_id, **kwargs): 5149 """ 5150 Get watermark information. 5151 5152 This method makes a synchronous HTTP request by default. To make an 5153 asynchronous HTTP request, please define a `callback` function 5154 to be invoked when receiving the response. 5155 >>> def callback_function(response): 5156 >>> pprint(response) 5157 >>> 5158 >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function) 5159 5160 :param callback function: The callback function 5161 for asynchronous request. (optional) 5162 :param str account_id: The external account number (int) or account ID Guid. (required) 5163 :return: Watermark 5164 If the method is called asynchronously, 5165 returns the request thread. 5166 """ 5167 5168 all_params = ['account_id'] 5169 all_params.append('callback') 5170 all_params.append('_return_http_data_only') 5171 all_params.append('_preload_content') 5172 all_params.append('_request_timeout') 5173 5174 params = locals() 5175 for key, val in iteritems(params['kwargs']): 5176 if key not in all_params: 5177 raise TypeError( 5178 "Got an unexpected keyword argument '%s'" 5179 " to method get_watermark" % key 5180 ) 5181 params[key] = val 5182 del params['kwargs'] 5183 # verify the required parameter 'account_id' is set 5184 if ('account_id' not in params) or (params['account_id'] is None): 5185 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`") 5186 5187 5188 collection_formats = {} 5189 5190 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 5191 path_params = {} 5192 if 'account_id' in params: 5193 path_params['accountId'] = params['account_id'] 5194 5195 query_params = {} 5196 5197 header_params = {} 5198 5199 form_params = [] 5200 local_var_files = {} 5201 5202 body_params = None 5203 # HTTP header `Accept` 5204 header_params['Accept'] = self.api_client.\ 5205 select_header_accept(['application/json']) 5206 5207 # Authentication setting 5208 auth_settings = [] 5209 5210 return self.api_client.call_api(resource_path, 'GET', 5211 path_params, 5212 query_params, 5213 header_params, 5214 body=body_params, 5215 post_params=form_params, 5216 files=local_var_files, 5217 response_type='Watermark', 5218 auth_settings=auth_settings, 5219 callback=params.get('callback'), 5220 _return_http_data_only=params.get('_return_http_data_only'), 5221 _preload_content=params.get('_preload_content', True), 5222 _request_timeout=params.get('_request_timeout'), 5223 collection_formats=collection_formats) 5224 5225 def get_watermark_preview(self, account_id, **kwargs): 5226 """ 5227 Get watermark preview. 5228 5229 This method makes a synchronous HTTP request by default. To make an 5230 asynchronous HTTP request, please define a `callback` function 5231 to be invoked when receiving the response. 5232 >>> def callback_function(response): 5233 >>> pprint(response) 5234 >>> 5235 >>> thread = api.get_watermark_preview(account_id, callback=callback_function) 5236 5237 :param callback function: The callback function 5238 for asynchronous request. (optional) 5239 :param str account_id: The external account number (int) or account ID Guid. (required) 5240 :param Watermark watermark: 5241 :return: Watermark 5242 If the method is called asynchronously, 5243 returns the request thread. 5244 """ 5245 kwargs['_return_http_data_only'] = True 5246 if kwargs.get('callback'): 5247 return self.get_watermark_preview_with_http_info(account_id, **kwargs) 5248 else: 5249 (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs) 5250 return data 5251 5252 def get_watermark_preview_with_http_info(self, account_id, **kwargs): 5253 """ 5254 Get watermark preview. 5255 5256 This method makes a synchronous HTTP request by default. To make an 5257 asynchronous HTTP request, please define a `callback` function 5258 to be invoked when receiving the response. 5259 >>> def callback_function(response): 5260 >>> pprint(response) 5261 >>> 5262 >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function) 5263 5264 :param callback function: The callback function 5265 for asynchronous request. (optional) 5266 :param str account_id: The external account number (int) or account ID Guid. (required) 5267 :param Watermark watermark: 5268 :return: Watermark 5269 If the method is called asynchronously, 5270 returns the request thread. 5271 """ 5272 5273 all_params = ['account_id', 'watermark'] 5274 all_params.append('callback') 5275 all_params.append('_return_http_data_only') 5276 all_params.append('_preload_content') 5277 all_params.append('_request_timeout') 5278 5279 params = locals() 5280 for key, val in iteritems(params['kwargs']): 5281 if key not in all_params: 5282 raise TypeError( 5283 "Got an unexpected keyword argument '%s'" 5284 " to method get_watermark_preview" % key 5285 ) 5286 params[key] = val 5287 del params['kwargs'] 5288 # verify the required parameter 'account_id' is set 5289 if ('account_id' not in params) or (params['account_id'] is None): 5290 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`") 5291 5292 5293 collection_formats = {} 5294 5295 resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json') 5296 path_params = {} 5297 if 'account_id' in params: 5298 path_params['accountId'] = params['account_id'] 5299 5300 query_params = {} 5301 5302 header_params = {} 5303 5304 form_params = [] 5305 local_var_files = {} 5306 5307 body_params = None 5308 if 'watermark' in params: 5309 body_params = params['watermark'] 5310 # HTTP header `Accept` 5311 header_params['Accept'] = self.api_client.\ 5312 select_header_accept(['application/json']) 5313 5314 # Authentication setting 5315 auth_settings = [] 5316 5317 return self.api_client.call_api(resource_path, 'PUT', 5318 path_params, 5319 query_params, 5320 header_params, 5321 body=body_params, 5322 post_params=form_params, 5323 files=local_var_files, 5324 response_type='Watermark', 5325 auth_settings=auth_settings, 5326 callback=params.get('callback'), 5327 _return_http_data_only=params.get('_return_http_data_only'), 5328 _preload_content=params.get('_preload_content', True), 5329 _request_timeout=params.get('_request_timeout'), 5330 collection_formats=collection_formats) 5331 5332 def list_brands(self, account_id, **kwargs): 5333 """ 5334 Gets a list of brand profiles. 5335 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. 5336 This method makes a synchronous HTTP request by default. To make an 5337 asynchronous HTTP request, please define a `callback` function 5338 to be invoked when receiving the response. 5339 >>> def callback_function(response): 5340 >>> pprint(response) 5341 >>> 5342 >>> thread = api.list_brands(account_id, callback=callback_function) 5343 5344 :param callback function: The callback function 5345 for asynchronous request. (optional) 5346 :param str account_id: The external account number (int) or account ID Guid. (required) 5347 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5348 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5349 :return: BrandsResponse 5350 If the method is called asynchronously, 5351 returns the request thread. 5352 """ 5353 kwargs['_return_http_data_only'] = True 5354 if kwargs.get('callback'): 5355 return self.list_brands_with_http_info(account_id, **kwargs) 5356 else: 5357 (data) = self.list_brands_with_http_info(account_id, **kwargs) 5358 return data 5359 5360 def list_brands_with_http_info(self, account_id, **kwargs): 5361 """ 5362 Gets a list of brand profiles. 5363 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. 5364 This method makes a synchronous HTTP request by default. To make an 5365 asynchronous HTTP request, please define a `callback` function 5366 to be invoked when receiving the response. 5367 >>> def callback_function(response): 5368 >>> pprint(response) 5369 >>> 5370 >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function) 5371 5372 :param callback function: The callback function 5373 for asynchronous request. (optional) 5374 :param str account_id: The external account number (int) or account ID Guid. (required) 5375 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5376 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5377 :return: BrandsResponse 5378 If the method is called asynchronously, 5379 returns the request thread. 5380 """ 5381 5382 all_params = ['account_id', 'exclude_distributor_brand', 'include_logos'] 5383 all_params.append('callback') 5384 all_params.append('_return_http_data_only') 5385 all_params.append('_preload_content') 5386 all_params.append('_request_timeout') 5387 5388 params = locals() 5389 for key, val in iteritems(params['kwargs']): 5390 if key not in all_params: 5391 raise TypeError( 5392 "Got an unexpected keyword argument '%s'" 5393 " to method list_brands" % key 5394 ) 5395 params[key] = val 5396 del params['kwargs'] 5397 # verify the required parameter 'account_id' is set 5398 if ('account_id' not in params) or (params['account_id'] is None): 5399 raise ValueError("Missing the required parameter `account_id` when calling `list_brands`") 5400 5401 5402 collection_formats = {} 5403 5404 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 5405 path_params = {} 5406 if 'account_id' in params: 5407 path_params['accountId'] = params['account_id'] 5408 5409 query_params = {} 5410 if 'exclude_distributor_brand' in params: 5411 query_params['exclude_distributor_brand'] = params['exclude_distributor_brand'] 5412 if 'include_logos' in params: 5413 query_params['include_logos'] = params['include_logos'] 5414 5415 header_params = {} 5416 5417 form_params = [] 5418 local_var_files = {} 5419 5420 body_params = None 5421 # HTTP header `Accept` 5422 header_params['Accept'] = self.api_client.\ 5423 select_header_accept(['application/json']) 5424 5425 # Authentication setting 5426 auth_settings = [] 5427 5428 return self.api_client.call_api(resource_path, 'GET', 5429 path_params, 5430 query_params, 5431 header_params, 5432 body=body_params, 5433 post_params=form_params, 5434 files=local_var_files, 5435 response_type='BrandsResponse', 5436 auth_settings=auth_settings, 5437 callback=params.get('callback'), 5438 _return_http_data_only=params.get('_return_http_data_only'), 5439 _preload_content=params.get('_preload_content', True), 5440 _request_timeout=params.get('_request_timeout'), 5441 collection_formats=collection_formats) 5442 5443 def list_custom_fields(self, account_id, **kwargs): 5444 """ 5445 Gets a list of custom fields associated with the account. 5446 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. 5447 This method makes a synchronous HTTP request by default. To make an 5448 asynchronous HTTP request, please define a `callback` function 5449 to be invoked when receiving the response. 5450 >>> def callback_function(response): 5451 >>> pprint(response) 5452 >>> 5453 >>> thread = api.list_custom_fields(account_id, callback=callback_function) 5454 5455 :param callback function: The callback function 5456 for asynchronous request. (optional) 5457 :param str account_id: The external account number (int) or account ID Guid. (required) 5458 :return: CustomFields 5459 If the method is called asynchronously, 5460 returns the request thread. 5461 """ 5462 kwargs['_return_http_data_only'] = True 5463 if kwargs.get('callback'): 5464 return self.list_custom_fields_with_http_info(account_id, **kwargs) 5465 else: 5466 (data) = self.list_custom_fields_with_http_info(account_id, **kwargs) 5467 return data 5468 5469 def list_custom_fields_with_http_info(self, account_id, **kwargs): 5470 """ 5471 Gets a list of custom fields associated with the account. 5472 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. 5473 This method makes a synchronous HTTP request by default. To make an 5474 asynchronous HTTP request, please define a `callback` function 5475 to be invoked when receiving the response. 5476 >>> def callback_function(response): 5477 >>> pprint(response) 5478 >>> 5479 >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function) 5480 5481 :param callback function: The callback function 5482 for asynchronous request. (optional) 5483 :param str account_id: The external account number (int) or account ID Guid. (required) 5484 :return: CustomFields 5485 If the method is called asynchronously, 5486 returns the request thread. 5487 """ 5488 5489 all_params = ['account_id'] 5490 all_params.append('callback') 5491 all_params.append('_return_http_data_only') 5492 all_params.append('_preload_content') 5493 all_params.append('_request_timeout') 5494 5495 params = locals() 5496 for key, val in iteritems(params['kwargs']): 5497 if key not in all_params: 5498 raise TypeError( 5499 "Got an unexpected keyword argument '%s'" 5500 " to method list_custom_fields" % key 5501 ) 5502 params[key] = val 5503 del params['kwargs'] 5504 # verify the required parameter 'account_id' is set 5505 if ('account_id' not in params) or (params['account_id'] is None): 5506 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 5507 5508 5509 collection_formats = {} 5510 5511 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 5512 path_params = {} 5513 if 'account_id' in params: 5514 path_params['accountId'] = params['account_id'] 5515 5516 query_params = {} 5517 5518 header_params = {} 5519 5520 form_params = [] 5521 local_var_files = {} 5522 5523 body_params = None 5524 # HTTP header `Accept` 5525 header_params['Accept'] = self.api_client.\ 5526 select_header_accept(['application/json']) 5527 5528 # Authentication setting 5529 auth_settings = [] 5530 5531 return self.api_client.call_api(resource_path, 'GET', 5532 path_params, 5533 query_params, 5534 header_params, 5535 body=body_params, 5536 post_params=form_params, 5537 files=local_var_files, 5538 response_type='CustomFields', 5539 auth_settings=auth_settings, 5540 callback=params.get('callback'), 5541 _return_http_data_only=params.get('_return_http_data_only'), 5542 _preload_content=params.get('_preload_content', True), 5543 _request_timeout=params.get('_request_timeout'), 5544 collection_formats=collection_formats) 5545 5546 def list_permissions(self, account_id, **kwargs): 5547 """ 5548 Gets a list of permission profiles. 5549 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. 5550 This method makes a synchronous HTTP request by default. To make an 5551 asynchronous HTTP request, please define a `callback` function 5552 to be invoked when receiving the response. 5553 >>> def callback_function(response): 5554 >>> pprint(response) 5555 >>> 5556 >>> thread = api.list_permissions(account_id, callback=callback_function) 5557 5558 :param callback function: The callback function 5559 for asynchronous request. (optional) 5560 :param str account_id: The external account number (int) or account ID Guid. (required) 5561 :param str include: 5562 :return: PermissionProfileInformation 5563 If the method is called asynchronously, 5564 returns the request thread. 5565 """ 5566 kwargs['_return_http_data_only'] = True 5567 if kwargs.get('callback'): 5568 return self.list_permissions_with_http_info(account_id, **kwargs) 5569 else: 5570 (data) = self.list_permissions_with_http_info(account_id, **kwargs) 5571 return data 5572 5573 def list_permissions_with_http_info(self, account_id, **kwargs): 5574 """ 5575 Gets a list of permission profiles. 5576 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. 5577 This method makes a synchronous HTTP request by default. To make an 5578 asynchronous HTTP request, please define a `callback` function 5579 to be invoked when receiving the response. 5580 >>> def callback_function(response): 5581 >>> pprint(response) 5582 >>> 5583 >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function) 5584 5585 :param callback function: The callback function 5586 for asynchronous request. (optional) 5587 :param str account_id: The external account number (int) or account ID Guid. (required) 5588 :param str include: 5589 :return: PermissionProfileInformation 5590 If the method is called asynchronously, 5591 returns the request thread. 5592 """ 5593 5594 all_params = ['account_id', 'include'] 5595 all_params.append('callback') 5596 all_params.append('_return_http_data_only') 5597 all_params.append('_preload_content') 5598 all_params.append('_request_timeout') 5599 5600 params = locals() 5601 for key, val in iteritems(params['kwargs']): 5602 if key not in all_params: 5603 raise TypeError( 5604 "Got an unexpected keyword argument '%s'" 5605 " to method list_permissions" % key 5606 ) 5607 params[key] = val 5608 del params['kwargs'] 5609 # verify the required parameter 'account_id' is set 5610 if ('account_id' not in params) or (params['account_id'] is None): 5611 raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`") 5612 5613 5614 collection_formats = {} 5615 5616 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 5617 path_params = {} 5618 if 'account_id' in params: 5619 path_params['accountId'] = params['account_id'] 5620 5621 query_params = {} 5622 if 'include' in params: 5623 query_params['include'] = params['include'] 5624 5625 header_params = {} 5626 5627 form_params = [] 5628 local_var_files = {} 5629 5630 body_params = None 5631 # HTTP header `Accept` 5632 header_params['Accept'] = self.api_client.\ 5633 select_header_accept(['application/json']) 5634 5635 # Authentication setting 5636 auth_settings = [] 5637 5638 return self.api_client.call_api(resource_path, 'GET', 5639 path_params, 5640 query_params, 5641 header_params, 5642 body=body_params, 5643 post_params=form_params, 5644 files=local_var_files, 5645 response_type='PermissionProfileInformation', 5646 auth_settings=auth_settings, 5647 callback=params.get('callback'), 5648 _return_http_data_only=params.get('_return_http_data_only'), 5649 _preload_content=params.get('_preload_content', True), 5650 _request_timeout=params.get('_request_timeout'), 5651 collection_formats=collection_formats) 5652 5653 def list_recipient_names_by_email(self, account_id, **kwargs): 5654 """ 5655 Gets recipient names associated with an email address. 5656 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5657 This method makes a synchronous HTTP request by default. To make an 5658 asynchronous HTTP request, please define a `callback` function 5659 to be invoked when receiving the response. 5660 >>> def callback_function(response): 5661 >>> pprint(response) 5662 >>> 5663 >>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function) 5664 5665 :param callback function: The callback function 5666 for asynchronous request. (optional) 5667 :param str account_id: The external account number (int) or account ID Guid. (required) 5668 :param str email: The email address for the user 5669 :return: RecipientNamesResponse 5670 If the method is called asynchronously, 5671 returns the request thread. 5672 """ 5673 kwargs['_return_http_data_only'] = True 5674 if kwargs.get('callback'): 5675 return self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5676 else: 5677 (data) = self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5678 return data 5679 5680 def list_recipient_names_by_email_with_http_info(self, account_id, **kwargs): 5681 """ 5682 Gets recipient names associated with an email address. 5683 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5684 This method makes a synchronous HTTP request by default. To make an 5685 asynchronous HTTP request, please define a `callback` function 5686 to be invoked when receiving the response. 5687 >>> def callback_function(response): 5688 >>> pprint(response) 5689 >>> 5690 >>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function) 5691 5692 :param callback function: The callback function 5693 for asynchronous request. (optional) 5694 :param str account_id: The external account number (int) or account ID Guid. (required) 5695 :param str email: The email address for the user 5696 :return: RecipientNamesResponse 5697 If the method is called asynchronously, 5698 returns the request thread. 5699 """ 5700 5701 all_params = ['account_id', 'email'] 5702 all_params.append('callback') 5703 all_params.append('_return_http_data_only') 5704 all_params.append('_preload_content') 5705 all_params.append('_request_timeout') 5706 5707 params = locals() 5708 for key, val in iteritems(params['kwargs']): 5709 if key not in all_params: 5710 raise TypeError( 5711 "Got an unexpected keyword argument '%s'" 5712 " to method list_recipient_names_by_email" % key 5713 ) 5714 params[key] = val 5715 del params['kwargs'] 5716 # verify the required parameter 'account_id' is set 5717 if ('account_id' not in params) or (params['account_id'] is None): 5718 raise ValueError("Missing the required parameter `account_id` when calling `list_recipient_names_by_email`") 5719 5720 5721 collection_formats = {} 5722 5723 resource_path = '/v2.1/accounts/{accountId}/recipient_names'.replace('{format}', 'json') 5724 path_params = {} 5725 if 'account_id' in params: 5726 path_params['accountId'] = params['account_id'] 5727 5728 query_params = {} 5729 if 'email' in params: 5730 query_params['email'] = params['email'] 5731 5732 header_params = {} 5733 5734 form_params = [] 5735 local_var_files = {} 5736 5737 body_params = None 5738 # HTTP header `Accept` 5739 header_params['Accept'] = self.api_client.\ 5740 select_header_accept(['application/json']) 5741 5742 # Authentication setting 5743 auth_settings = [] 5744 5745 return self.api_client.call_api(resource_path, 'GET', 5746 path_params, 5747 query_params, 5748 header_params, 5749 body=body_params, 5750 post_params=form_params, 5751 files=local_var_files, 5752 response_type='RecipientNamesResponse', 5753 auth_settings=auth_settings, 5754 callback=params.get('callback'), 5755 _return_http_data_only=params.get('_return_http_data_only'), 5756 _preload_content=params.get('_preload_content', True), 5757 _request_timeout=params.get('_request_timeout'), 5758 collection_formats=collection_formats) 5759 5760 def list_settings(self, account_id, **kwargs): 5761 """ 5762 Gets account settings information. 5763 Retrieves the account settings information for the specified account. 5764 This method makes a synchronous HTTP request by default. To make an 5765 asynchronous HTTP request, please define a `callback` function 5766 to be invoked when receiving the response. 5767 >>> def callback_function(response): 5768 >>> pprint(response) 5769 >>> 5770 >>> thread = api.list_settings(account_id, callback=callback_function) 5771 5772 :param callback function: The callback function 5773 for asynchronous request. (optional) 5774 :param str account_id: The external account number (int) or account ID Guid. (required) 5775 :return: AccountSettingsInformation 5776 If the method is called asynchronously, 5777 returns the request thread. 5778 """ 5779 kwargs['_return_http_data_only'] = True 5780 if kwargs.get('callback'): 5781 return self.list_settings_with_http_info(account_id, **kwargs) 5782 else: 5783 (data) = self.list_settings_with_http_info(account_id, **kwargs) 5784 return data 5785 5786 def list_settings_with_http_info(self, account_id, **kwargs): 5787 """ 5788 Gets account settings information. 5789 Retrieves the account settings information for the specified account. 5790 This method makes a synchronous HTTP request by default. To make an 5791 asynchronous HTTP request, please define a `callback` function 5792 to be invoked when receiving the response. 5793 >>> def callback_function(response): 5794 >>> pprint(response) 5795 >>> 5796 >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function) 5797 5798 :param callback function: The callback function 5799 for asynchronous request. (optional) 5800 :param str account_id: The external account number (int) or account ID Guid. (required) 5801 :return: AccountSettingsInformation 5802 If the method is called asynchronously, 5803 returns the request thread. 5804 """ 5805 5806 all_params = ['account_id'] 5807 all_params.append('callback') 5808 all_params.append('_return_http_data_only') 5809 all_params.append('_preload_content') 5810 all_params.append('_request_timeout') 5811 5812 params = locals() 5813 for key, val in iteritems(params['kwargs']): 5814 if key not in all_params: 5815 raise TypeError( 5816 "Got an unexpected keyword argument '%s'" 5817 " to method list_settings" % key 5818 ) 5819 params[key] = val 5820 del params['kwargs'] 5821 # verify the required parameter 'account_id' is set 5822 if ('account_id' not in params) or (params['account_id'] is None): 5823 raise ValueError("Missing the required parameter `account_id` when calling `list_settings`") 5824 5825 5826 collection_formats = {} 5827 5828 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 5829 path_params = {} 5830 if 'account_id' in params: 5831 path_params['accountId'] = params['account_id'] 5832 5833 query_params = {} 5834 5835 header_params = {} 5836 5837 form_params = [] 5838 local_var_files = {} 5839 5840 body_params = None 5841 # HTTP header `Accept` 5842 header_params['Accept'] = self.api_client.\ 5843 select_header_accept(['application/json']) 5844 5845 # Authentication setting 5846 auth_settings = [] 5847 5848 return self.api_client.call_api(resource_path, 'GET', 5849 path_params, 5850 query_params, 5851 header_params, 5852 body=body_params, 5853 post_params=form_params, 5854 files=local_var_files, 5855 response_type='AccountSettingsInformation', 5856 auth_settings=auth_settings, 5857 callback=params.get('callback'), 5858 _return_http_data_only=params.get('_return_http_data_only'), 5859 _preload_content=params.get('_preload_content', True), 5860 _request_timeout=params.get('_request_timeout'), 5861 collection_formats=collection_formats) 5862 5863 def list_shared_access(self, account_id, **kwargs): 5864 """ 5865 Reserved: Gets the shared item status for one or more users. 5866 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. 5867 This method makes a synchronous HTTP request by default. To make an 5868 asynchronous HTTP request, please define a `callback` function 5869 to be invoked when receiving the response. 5870 >>> def callback_function(response): 5871 >>> pprint(response) 5872 >>> 5873 >>> thread = api.list_shared_access(account_id, callback=callback_function) 5874 5875 :param callback function: The callback function 5876 for asynchronous request. (optional) 5877 :param str account_id: The external account number (int) or account ID Guid. (required) 5878 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5879 :param str envelopes_not_shared_user_status: 5880 :param str folder_ids: 5881 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5882 :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. 5883 :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 5884 :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. 5885 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 5886 :return: AccountSharedAccess 5887 If the method is called asynchronously, 5888 returns the request thread. 5889 """ 5890 kwargs['_return_http_data_only'] = True 5891 if kwargs.get('callback'): 5892 return self.list_shared_access_with_http_info(account_id, **kwargs) 5893 else: 5894 (data) = self.list_shared_access_with_http_info(account_id, **kwargs) 5895 return data 5896 5897 def list_shared_access_with_http_info(self, account_id, **kwargs): 5898 """ 5899 Reserved: Gets the shared item status for one or more users. 5900 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. 5901 This method makes a synchronous HTTP request by default. To make an 5902 asynchronous HTTP request, please define a `callback` function 5903 to be invoked when receiving the response. 5904 >>> def callback_function(response): 5905 >>> pprint(response) 5906 >>> 5907 >>> thread = api.list_shared_access_with_http_info(account_id, callback=callback_function) 5908 5909 :param callback function: The callback function 5910 for asynchronous request. (optional) 5911 :param str account_id: The external account number (int) or account ID Guid. (required) 5912 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5913 :param str envelopes_not_shared_user_status: 5914 :param str folder_ids: 5915 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5916 :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. 5917 :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 5918 :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. 5919 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 5920 :return: AccountSharedAccess 5921 If the method is called asynchronously, 5922 returns the request thread. 5923 """ 5924 5925 all_params = ['account_id', 'count', 'envelopes_not_shared_user_status', 'folder_ids', 'item_type', 'search_text', 'shared', 'start_position', 'user_ids'] 5926 all_params.append('callback') 5927 all_params.append('_return_http_data_only') 5928 all_params.append('_preload_content') 5929 all_params.append('_request_timeout') 5930 5931 params = locals() 5932 for key, val in iteritems(params['kwargs']): 5933 if key not in all_params: 5934 raise TypeError( 5935 "Got an unexpected keyword argument '%s'" 5936 " to method list_shared_access" % key 5937 ) 5938 params[key] = val 5939 del params['kwargs'] 5940 # verify the required parameter 'account_id' is set 5941 if ('account_id' not in params) or (params['account_id'] is None): 5942 raise ValueError("Missing the required parameter `account_id` when calling `list_shared_access`") 5943 5944 5945 collection_formats = {} 5946 5947 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 5948 path_params = {} 5949 if 'account_id' in params: 5950 path_params['accountId'] = params['account_id'] 5951 5952 query_params = {} 5953 if 'count' in params: 5954 query_params['count'] = params['count'] 5955 if 'envelopes_not_shared_user_status' in params: 5956 query_params['envelopes_not_shared_user_status'] = params['envelopes_not_shared_user_status'] 5957 if 'folder_ids' in params: 5958 query_params['folder_ids'] = params['folder_ids'] 5959 if 'item_type' in params: 5960 query_params['item_type'] = params['item_type'] 5961 if 'search_text' in params: 5962 query_params['search_text'] = params['search_text'] 5963 if 'shared' in params: 5964 query_params['shared'] = params['shared'] 5965 if 'start_position' in params: 5966 query_params['start_position'] = params['start_position'] 5967 if 'user_ids' in params: 5968 query_params['user_ids'] = params['user_ids'] 5969 5970 header_params = {} 5971 5972 form_params = [] 5973 local_var_files = {} 5974 5975 body_params = None 5976 # HTTP header `Accept` 5977 header_params['Accept'] = self.api_client.\ 5978 select_header_accept(['application/json']) 5979 5980 # Authentication setting 5981 auth_settings = [] 5982 5983 return self.api_client.call_api(resource_path, 'GET', 5984 path_params, 5985 query_params, 5986 header_params, 5987 body=body_params, 5988 post_params=form_params, 5989 files=local_var_files, 5990 response_type='AccountSharedAccess', 5991 auth_settings=auth_settings, 5992 callback=params.get('callback'), 5993 _return_http_data_only=params.get('_return_http_data_only'), 5994 _preload_content=params.get('_preload_content', True), 5995 _request_timeout=params.get('_request_timeout'), 5996 collection_formats=collection_formats) 5997 5998 def list_signature_providers(self, account_id, **kwargs): 5999 """ 6000 Returns Account available signature providers for specified account. 6001 Returns a list of signature providers that the specified account can use. 6002 This method makes a synchronous HTTP request by default. To make an 6003 asynchronous HTTP request, please define a `callback` function 6004 to be invoked when receiving the response. 6005 >>> def callback_function(response): 6006 >>> pprint(response) 6007 >>> 6008 >>> thread = api.list_signature_providers(account_id, callback=callback_function) 6009 6010 :param callback function: The callback function 6011 for asynchronous request. (optional) 6012 :param str account_id: The external account number (int) or account ID Guid. (required) 6013 :return: AccountSignatureProviders 6014 If the method is called asynchronously, 6015 returns the request thread. 6016 """ 6017 kwargs['_return_http_data_only'] = True 6018 if kwargs.get('callback'): 6019 return self.list_signature_providers_with_http_info(account_id, **kwargs) 6020 else: 6021 (data) = self.list_signature_providers_with_http_info(account_id, **kwargs) 6022 return data 6023 6024 def list_signature_providers_with_http_info(self, account_id, **kwargs): 6025 """ 6026 Returns Account available signature providers for specified account. 6027 Returns a list of signature providers that the specified account can use. 6028 This method makes a synchronous HTTP request by default. To make an 6029 asynchronous HTTP request, please define a `callback` function 6030 to be invoked when receiving the response. 6031 >>> def callback_function(response): 6032 >>> pprint(response) 6033 >>> 6034 >>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function) 6035 6036 :param callback function: The callback function 6037 for asynchronous request. (optional) 6038 :param str account_id: The external account number (int) or account ID Guid. (required) 6039 :return: AccountSignatureProviders 6040 If the method is called asynchronously, 6041 returns the request thread. 6042 """ 6043 6044 all_params = ['account_id'] 6045 all_params.append('callback') 6046 all_params.append('_return_http_data_only') 6047 all_params.append('_preload_content') 6048 all_params.append('_request_timeout') 6049 6050 params = locals() 6051 for key, val in iteritems(params['kwargs']): 6052 if key not in all_params: 6053 raise TypeError( 6054 "Got an unexpected keyword argument '%s'" 6055 " to method list_signature_providers" % key 6056 ) 6057 params[key] = val 6058 del params['kwargs'] 6059 # verify the required parameter 'account_id' is set 6060 if ('account_id' not in params) or (params['account_id'] is None): 6061 raise ValueError("Missing the required parameter `account_id` when calling `list_signature_providers`") 6062 6063 6064 collection_formats = {} 6065 6066 resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.replace('{format}', 'json') 6067 path_params = {} 6068 if 'account_id' in params: 6069 path_params['accountId'] = params['account_id'] 6070 6071 query_params = {} 6072 6073 header_params = {} 6074 6075 form_params = [] 6076 local_var_files = {} 6077 6078 body_params = None 6079 # HTTP header `Accept` 6080 header_params['Accept'] = self.api_client.\ 6081 select_header_accept(['application/json']) 6082 6083 # Authentication setting 6084 auth_settings = [] 6085 6086 return self.api_client.call_api(resource_path, 'GET', 6087 path_params, 6088 query_params, 6089 header_params, 6090 body=body_params, 6091 post_params=form_params, 6092 files=local_var_files, 6093 response_type='AccountSignatureProviders', 6094 auth_settings=auth_settings, 6095 callback=params.get('callback'), 6096 _return_http_data_only=params.get('_return_http_data_only'), 6097 _preload_content=params.get('_preload_content', True), 6098 _request_timeout=params.get('_request_timeout'), 6099 collection_formats=collection_formats) 6100 6101 def list_unsupported_file_types(self, account_id, **kwargs): 6102 """ 6103 Gets a list of unsupported file types. 6104 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6105 This method makes a synchronous HTTP request by default. To make an 6106 asynchronous HTTP request, please define a `callback` function 6107 to be invoked when receiving the response. 6108 >>> def callback_function(response): 6109 >>> pprint(response) 6110 >>> 6111 >>> thread = api.list_unsupported_file_types(account_id, callback=callback_function) 6112 6113 :param callback function: The callback function 6114 for asynchronous request. (optional) 6115 :param str account_id: The external account number (int) or account ID Guid. (required) 6116 :return: FileTypeList 6117 If the method is called asynchronously, 6118 returns the request thread. 6119 """ 6120 kwargs['_return_http_data_only'] = True 6121 if kwargs.get('callback'): 6122 return self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6123 else: 6124 (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6125 return data 6126 6127 def list_unsupported_file_types_with_http_info(self, account_id, **kwargs): 6128 """ 6129 Gets a list of unsupported file types. 6130 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6131 This method makes a synchronous HTTP request by default. To make an 6132 asynchronous HTTP request, please define a `callback` function 6133 to be invoked when receiving the response. 6134 >>> def callback_function(response): 6135 >>> pprint(response) 6136 >>> 6137 >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function) 6138 6139 :param callback function: The callback function 6140 for asynchronous request. (optional) 6141 :param str account_id: The external account number (int) or account ID Guid. (required) 6142 :return: FileTypeList 6143 If the method is called asynchronously, 6144 returns the request thread. 6145 """ 6146 6147 all_params = ['account_id'] 6148 all_params.append('callback') 6149 all_params.append('_return_http_data_only') 6150 all_params.append('_preload_content') 6151 all_params.append('_request_timeout') 6152 6153 params = locals() 6154 for key, val in iteritems(params['kwargs']): 6155 if key not in all_params: 6156 raise TypeError( 6157 "Got an unexpected keyword argument '%s'" 6158 " to method list_unsupported_file_types" % key 6159 ) 6160 params[key] = val 6161 del params['kwargs'] 6162 # verify the required parameter 'account_id' is set 6163 if ('account_id' not in params) or (params['account_id'] is None): 6164 raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`") 6165 6166 6167 collection_formats = {} 6168 6169 resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json') 6170 path_params = {} 6171 if 'account_id' in params: 6172 path_params['accountId'] = params['account_id'] 6173 6174 query_params = {} 6175 6176 header_params = {} 6177 6178 form_params = [] 6179 local_var_files = {} 6180 6181 body_params = None 6182 # HTTP header `Accept` 6183 header_params['Accept'] = self.api_client.\ 6184 select_header_accept(['application/json']) 6185 6186 # Authentication setting 6187 auth_settings = [] 6188 6189 return self.api_client.call_api(resource_path, 'GET', 6190 path_params, 6191 query_params, 6192 header_params, 6193 body=body_params, 6194 post_params=form_params, 6195 files=local_var_files, 6196 response_type='FileTypeList', 6197 auth_settings=auth_settings, 6198 callback=params.get('callback'), 6199 _return_http_data_only=params.get('_return_http_data_only'), 6200 _preload_content=params.get('_preload_content', True), 6201 _request_timeout=params.get('_request_timeout'), 6202 collection_formats=collection_formats) 6203 6204 def un_favorite_template(self, account_id, **kwargs): 6205 """ 6206 Unfavorite a template 6207 6208 This method makes a synchronous HTTP request by default. To make an 6209 asynchronous HTTP request, please define a `callback` function 6210 to be invoked when receiving the response. 6211 >>> def callback_function(response): 6212 >>> pprint(response) 6213 >>> 6214 >>> thread = api.un_favorite_template(account_id, callback=callback_function) 6215 6216 :param callback function: The callback function 6217 for asynchronous request. (optional) 6218 :param str account_id: The external account number (int) or account ID Guid. (required) 6219 :param FavoriteTemplatesInfo favorite_templates_info: 6220 :return: FavoriteTemplatesInfo 6221 If the method is called asynchronously, 6222 returns the request thread. 6223 """ 6224 kwargs['_return_http_data_only'] = True 6225 if kwargs.get('callback'): 6226 return self.un_favorite_template_with_http_info(account_id, **kwargs) 6227 else: 6228 (data) = self.un_favorite_template_with_http_info(account_id, **kwargs) 6229 return data 6230 6231 def un_favorite_template_with_http_info(self, account_id, **kwargs): 6232 """ 6233 Unfavorite a template 6234 6235 This method makes a synchronous HTTP request by default. To make an 6236 asynchronous HTTP request, please define a `callback` function 6237 to be invoked when receiving the response. 6238 >>> def callback_function(response): 6239 >>> pprint(response) 6240 >>> 6241 >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function) 6242 6243 :param callback function: The callback function 6244 for asynchronous request. (optional) 6245 :param str account_id: The external account number (int) or account ID Guid. (required) 6246 :param FavoriteTemplatesInfo favorite_templates_info: 6247 :return: FavoriteTemplatesInfo 6248 If the method is called asynchronously, 6249 returns the request thread. 6250 """ 6251 6252 all_params = ['account_id', 'favorite_templates_info'] 6253 all_params.append('callback') 6254 all_params.append('_return_http_data_only') 6255 all_params.append('_preload_content') 6256 all_params.append('_request_timeout') 6257 6258 params = locals() 6259 for key, val in iteritems(params['kwargs']): 6260 if key not in all_params: 6261 raise TypeError( 6262 "Got an unexpected keyword argument '%s'" 6263 " to method un_favorite_template" % key 6264 ) 6265 params[key] = val 6266 del params['kwargs'] 6267 # verify the required parameter 'account_id' is set 6268 if ('account_id' not in params) or (params['account_id'] is None): 6269 raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`") 6270 6271 6272 collection_formats = {} 6273 6274 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 6275 path_params = {} 6276 if 'account_id' in params: 6277 path_params['accountId'] = params['account_id'] 6278 6279 query_params = {} 6280 6281 header_params = {} 6282 6283 form_params = [] 6284 local_var_files = {} 6285 6286 body_params = None 6287 if 'favorite_templates_info' in params: 6288 body_params = params['favorite_templates_info'] 6289 # HTTP header `Accept` 6290 header_params['Accept'] = self.api_client.\ 6291 select_header_accept(['application/json']) 6292 6293 # Authentication setting 6294 auth_settings = [] 6295 6296 return self.api_client.call_api(resource_path, 'DELETE', 6297 path_params, 6298 query_params, 6299 header_params, 6300 body=body_params, 6301 post_params=form_params, 6302 files=local_var_files, 6303 response_type='FavoriteTemplatesInfo', 6304 auth_settings=auth_settings, 6305 callback=params.get('callback'), 6306 _return_http_data_only=params.get('_return_http_data_only'), 6307 _preload_content=params.get('_preload_content', True), 6308 _request_timeout=params.get('_request_timeout'), 6309 collection_formats=collection_formats) 6310 6311 def update_account_signature(self, account_id, **kwargs): 6312 """ 6313 Updates a account signature. 6314 6315 This method makes a synchronous HTTP request by default. To make an 6316 asynchronous HTTP request, please define a `callback` function 6317 to be invoked when receiving the response. 6318 >>> def callback_function(response): 6319 >>> pprint(response) 6320 >>> 6321 >>> thread = api.update_account_signature(account_id, callback=callback_function) 6322 6323 :param callback function: The callback function 6324 for asynchronous request. (optional) 6325 :param str account_id: The external account number (int) or account ID Guid. (required) 6326 :param AccountSignaturesInformation account_signatures_information: 6327 :return: AccountSignaturesInformation 6328 If the method is called asynchronously, 6329 returns the request thread. 6330 """ 6331 kwargs['_return_http_data_only'] = True 6332 if kwargs.get('callback'): 6333 return self.update_account_signature_with_http_info(account_id, **kwargs) 6334 else: 6335 (data) = self.update_account_signature_with_http_info(account_id, **kwargs) 6336 return data 6337 6338 def update_account_signature_with_http_info(self, account_id, **kwargs): 6339 """ 6340 Updates a account signature. 6341 6342 This method makes a synchronous HTTP request by default. To make an 6343 asynchronous HTTP request, please define a `callback` function 6344 to be invoked when receiving the response. 6345 >>> def callback_function(response): 6346 >>> pprint(response) 6347 >>> 6348 >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function) 6349 6350 :param callback function: The callback function 6351 for asynchronous request. (optional) 6352 :param str account_id: The external account number (int) or account ID Guid. (required) 6353 :param AccountSignaturesInformation account_signatures_information: 6354 :return: AccountSignaturesInformation 6355 If the method is called asynchronously, 6356 returns the request thread. 6357 """ 6358 6359 all_params = ['account_id', 'account_signatures_information'] 6360 all_params.append('callback') 6361 all_params.append('_return_http_data_only') 6362 all_params.append('_preload_content') 6363 all_params.append('_request_timeout') 6364 6365 params = locals() 6366 for key, val in iteritems(params['kwargs']): 6367 if key not in all_params: 6368 raise TypeError( 6369 "Got an unexpected keyword argument '%s'" 6370 " to method update_account_signature" % key 6371 ) 6372 params[key] = val 6373 del params['kwargs'] 6374 # verify the required parameter 'account_id' is set 6375 if ('account_id' not in params) or (params['account_id'] is None): 6376 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`") 6377 6378 6379 collection_formats = {} 6380 6381 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 6382 path_params = {} 6383 if 'account_id' in params: 6384 path_params['accountId'] = params['account_id'] 6385 6386 query_params = {} 6387 6388 header_params = {} 6389 6390 form_params = [] 6391 local_var_files = {} 6392 6393 body_params = None 6394 if 'account_signatures_information' in params: 6395 body_params = params['account_signatures_information'] 6396 # HTTP header `Accept` 6397 header_params['Accept'] = self.api_client.\ 6398 select_header_accept(['application/json']) 6399 6400 # Authentication setting 6401 auth_settings = [] 6402 6403 return self.api_client.call_api(resource_path, 'PUT', 6404 path_params, 6405 query_params, 6406 header_params, 6407 body=body_params, 6408 post_params=form_params, 6409 files=local_var_files, 6410 response_type='AccountSignaturesInformation', 6411 auth_settings=auth_settings, 6412 callback=params.get('callback'), 6413 _return_http_data_only=params.get('_return_http_data_only'), 6414 _preload_content=params.get('_preload_content', True), 6415 _request_timeout=params.get('_request_timeout'), 6416 collection_formats=collection_formats) 6417 6418 def update_account_signature_by_id(self, account_id, signature_id, **kwargs): 6419 """ 6420 Updates a account signature. 6421 6422 This method makes a synchronous HTTP request by default. To make an 6423 asynchronous HTTP request, please define a `callback` function 6424 to be invoked when receiving the response. 6425 >>> def callback_function(response): 6426 >>> pprint(response) 6427 >>> 6428 >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function) 6429 6430 :param callback function: The callback function 6431 for asynchronous request. (optional) 6432 :param str account_id: The external account number (int) or account ID Guid. (required) 6433 :param str signature_id: The ID of the signature being accessed. (required) 6434 :param str close_existing_signature: 6435 :param AccountSignatureDefinition account_signature_definition: 6436 :return: AccountSignature 6437 If the method is called asynchronously, 6438 returns the request thread. 6439 """ 6440 kwargs['_return_http_data_only'] = True 6441 if kwargs.get('callback'): 6442 return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6443 else: 6444 (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6445 return data 6446 6447 def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs): 6448 """ 6449 Updates a account signature. 6450 6451 This method makes a synchronous HTTP request by default. To make an 6452 asynchronous HTTP request, please define a `callback` function 6453 to be invoked when receiving the response. 6454 >>> def callback_function(response): 6455 >>> pprint(response) 6456 >>> 6457 >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function) 6458 6459 :param callback function: The callback function 6460 for asynchronous request. (optional) 6461 :param str account_id: The external account number (int) or account ID Guid. (required) 6462 :param str signature_id: The ID of the signature being accessed. (required) 6463 :param str close_existing_signature: 6464 :param AccountSignatureDefinition account_signature_definition: 6465 :return: AccountSignature 6466 If the method is called asynchronously, 6467 returns the request thread. 6468 """ 6469 6470 all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition'] 6471 all_params.append('callback') 6472 all_params.append('_return_http_data_only') 6473 all_params.append('_preload_content') 6474 all_params.append('_request_timeout') 6475 6476 params = locals() 6477 for key, val in iteritems(params['kwargs']): 6478 if key not in all_params: 6479 raise TypeError( 6480 "Got an unexpected keyword argument '%s'" 6481 " to method update_account_signature_by_id" % key 6482 ) 6483 params[key] = val 6484 del params['kwargs'] 6485 # verify the required parameter 'account_id' is set 6486 if ('account_id' not in params) or (params['account_id'] is None): 6487 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`") 6488 # verify the required parameter 'signature_id' is set 6489 if ('signature_id' not in params) or (params['signature_id'] is None): 6490 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`") 6491 6492 6493 collection_formats = {} 6494 6495 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 6496 path_params = {} 6497 if 'account_id' in params: 6498 path_params['accountId'] = params['account_id'] 6499 if 'signature_id' in params: 6500 path_params['signatureId'] = params['signature_id'] 6501 6502 query_params = {} 6503 if 'close_existing_signature' in params: 6504 query_params['close_existing_signature'] = params['close_existing_signature'] 6505 6506 header_params = {} 6507 6508 form_params = [] 6509 local_var_files = {} 6510 6511 body_params = None 6512 if 'account_signature_definition' in params: 6513 body_params = params['account_signature_definition'] 6514 # HTTP header `Accept` 6515 header_params['Accept'] = self.api_client.\ 6516 select_header_accept(['application/json']) 6517 6518 # Authentication setting 6519 auth_settings = [] 6520 6521 return self.api_client.call_api(resource_path, 'PUT', 6522 path_params, 6523 query_params, 6524 header_params, 6525 body=body_params, 6526 post_params=form_params, 6527 files=local_var_files, 6528 response_type='AccountSignature', 6529 auth_settings=auth_settings, 6530 callback=params.get('callback'), 6531 _return_http_data_only=params.get('_return_http_data_only'), 6532 _preload_content=params.get('_preload_content', True), 6533 _request_timeout=params.get('_request_timeout'), 6534 collection_formats=collection_formats) 6535 6536 def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 6537 """ 6538 Sets a signature, initials, or stamps image. 6539 6540 This method makes a synchronous HTTP request by default. To make an 6541 asynchronous HTTP request, please define a `callback` function 6542 to be invoked when receiving the response. 6543 >>> def callback_function(response): 6544 >>> pprint(response) 6545 >>> 6546 >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 6547 6548 :param callback function: The callback function 6549 for asynchronous request. (optional) 6550 :param str account_id: The external account number (int) or account ID Guid. (required) 6551 :param str image_type: One of **signature_image** or **initials_image**. (required) 6552 :param str signature_id: The ID of the signature being accessed. (required) 6553 :param str transparent_png: 6554 :return: AccountSignature 6555 If the method is called asynchronously, 6556 returns the request thread. 6557 """ 6558 kwargs['_return_http_data_only'] = True 6559 if kwargs.get('callback'): 6560 return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6561 else: 6562 (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6563 return data 6564 6565 def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 6566 """ 6567 Sets a signature, initials, or stamps image. 6568 6569 This method makes a synchronous HTTP request by default. To make an 6570 asynchronous HTTP request, please define a `callback` function 6571 to be invoked when receiving the response. 6572 >>> def callback_function(response): 6573 >>> pprint(response) 6574 >>> 6575 >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 6576 6577 :param callback function: The callback function 6578 for asynchronous request. (optional) 6579 :param str account_id: The external account number (int) or account ID Guid. (required) 6580 :param str image_type: One of **signature_image** or **initials_image**. (required) 6581 :param str signature_id: The ID of the signature being accessed. (required) 6582 :param str transparent_png: 6583 :return: AccountSignature 6584 If the method is called asynchronously, 6585 returns the request thread. 6586 """ 6587 6588 all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png'] 6589 all_params.append('callback') 6590 all_params.append('_return_http_data_only') 6591 all_params.append('_preload_content') 6592 all_params.append('_request_timeout') 6593 6594 params = locals() 6595 for key, val in iteritems(params['kwargs']): 6596 if key not in all_params: 6597 raise TypeError( 6598 "Got an unexpected keyword argument '%s'" 6599 " to method update_account_signature_image" % key 6600 ) 6601 params[key] = val 6602 del params['kwargs'] 6603 # verify the required parameter 'account_id' is set 6604 if ('account_id' not in params) or (params['account_id'] is None): 6605 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`") 6606 # verify the required parameter 'image_type' is set 6607 if ('image_type' not in params) or (params['image_type'] is None): 6608 raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`") 6609 # verify the required parameter 'signature_id' is set 6610 if ('signature_id' not in params) or (params['signature_id'] is None): 6611 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`") 6612 6613 6614 collection_formats = {} 6615 6616 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 6617 path_params = {} 6618 if 'account_id' in params: 6619 path_params['accountId'] = params['account_id'] 6620 if 'image_type' in params: 6621 path_params['imageType'] = params['image_type'] 6622 if 'signature_id' in params: 6623 path_params['signatureId'] = params['signature_id'] 6624 6625 query_params = {} 6626 if 'transparent_png' in params: 6627 query_params['transparent_png'] = params['transparent_png'] 6628 6629 header_params = {} 6630 6631 form_params = [] 6632 local_var_files = {} 6633 6634 body_params = None 6635 # HTTP header `Accept` 6636 header_params['Accept'] = self.api_client.\ 6637 select_header_accept(['application/json']) 6638 6639 # HTTP header `Content-Type` 6640 header_params['Content-Type'] = self.api_client.\ 6641 select_header_content_type(['image/gif']) 6642 6643 # Authentication setting 6644 auth_settings = [] 6645 6646 return self.api_client.call_api(resource_path, 'PUT', 6647 path_params, 6648 query_params, 6649 header_params, 6650 body=body_params, 6651 post_params=form_params, 6652 files=local_var_files, 6653 response_type='AccountSignature', 6654 auth_settings=auth_settings, 6655 callback=params.get('callback'), 6656 _return_http_data_only=params.get('_return_http_data_only'), 6657 _preload_content=params.get('_preload_content', True), 6658 _request_timeout=params.get('_request_timeout'), 6659 collection_formats=collection_formats) 6660 6661 def update_account_tab_settings(self, account_id, **kwargs): 6662 """ 6663 Modifies tab settings for specified account 6664 This method modifies the tab types and tab functionality that is enabled for an account. 6665 This method makes a synchronous HTTP request by default. To make an 6666 asynchronous HTTP request, please define a `callback` function 6667 to be invoked when receiving the response. 6668 >>> def callback_function(response): 6669 >>> pprint(response) 6670 >>> 6671 >>> thread = api.update_account_tab_settings(account_id, callback=callback_function) 6672 6673 :param callback function: The callback function 6674 for asynchronous request. (optional) 6675 :param str account_id: The external account number (int) or account ID Guid. (required) 6676 :param TabAccountSettings tab_account_settings: 6677 :return: TabAccountSettings 6678 If the method is called asynchronously, 6679 returns the request thread. 6680 """ 6681 kwargs['_return_http_data_only'] = True 6682 if kwargs.get('callback'): 6683 return self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6684 else: 6685 (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6686 return data 6687 6688 def update_account_tab_settings_with_http_info(self, account_id, **kwargs): 6689 """ 6690 Modifies tab settings for specified account 6691 This method modifies the tab types and tab functionality that is enabled for an account. 6692 This method makes a synchronous HTTP request by default. To make an 6693 asynchronous HTTP request, please define a `callback` function 6694 to be invoked when receiving the response. 6695 >>> def callback_function(response): 6696 >>> pprint(response) 6697 >>> 6698 >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function) 6699 6700 :param callback function: The callback function 6701 for asynchronous request. (optional) 6702 :param str account_id: The external account number (int) or account ID Guid. (required) 6703 :param TabAccountSettings tab_account_settings: 6704 :return: TabAccountSettings 6705 If the method is called asynchronously, 6706 returns the request thread. 6707 """ 6708 6709 all_params = ['account_id', 'tab_account_settings'] 6710 all_params.append('callback') 6711 all_params.append('_return_http_data_only') 6712 all_params.append('_preload_content') 6713 all_params.append('_request_timeout') 6714 6715 params = locals() 6716 for key, val in iteritems(params['kwargs']): 6717 if key not in all_params: 6718 raise TypeError( 6719 "Got an unexpected keyword argument '%s'" 6720 " to method update_account_tab_settings" % key 6721 ) 6722 params[key] = val 6723 del params['kwargs'] 6724 # verify the required parameter 'account_id' is set 6725 if ('account_id' not in params) or (params['account_id'] is None): 6726 raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`") 6727 6728 6729 collection_formats = {} 6730 6731 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 6732 path_params = {} 6733 if 'account_id' in params: 6734 path_params['accountId'] = params['account_id'] 6735 6736 query_params = {} 6737 6738 header_params = {} 6739 6740 form_params = [] 6741 local_var_files = {} 6742 6743 body_params = None 6744 if 'tab_account_settings' in params: 6745 body_params = params['tab_account_settings'] 6746 # HTTP header `Accept` 6747 header_params['Accept'] = self.api_client.\ 6748 select_header_accept(['application/json']) 6749 6750 # Authentication setting 6751 auth_settings = [] 6752 6753 return self.api_client.call_api(resource_path, 'PUT', 6754 path_params, 6755 query_params, 6756 header_params, 6757 body=body_params, 6758 post_params=form_params, 6759 files=local_var_files, 6760 response_type='TabAccountSettings', 6761 auth_settings=auth_settings, 6762 callback=params.get('callback'), 6763 _return_http_data_only=params.get('_return_http_data_only'), 6764 _preload_content=params.get('_preload_content', True), 6765 _request_timeout=params.get('_request_timeout'), 6766 collection_formats=collection_formats) 6767 6768 def update_brand(self, account_id, brand_id, **kwargs): 6769 """ 6770 Updates an existing brand. 6771 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**). 6772 This method makes a synchronous HTTP request by default. To make an 6773 asynchronous HTTP request, please define a `callback` function 6774 to be invoked when receiving the response. 6775 >>> def callback_function(response): 6776 >>> pprint(response) 6777 >>> 6778 >>> thread = api.update_brand(account_id, brand_id, callback=callback_function) 6779 6780 :param callback function: The callback function 6781 for asynchronous request. (optional) 6782 :param str account_id: The external account number (int) or account ID Guid. (required) 6783 :param str brand_id: The unique identifier of a brand. (required) 6784 :param str replace_brand: 6785 :param Brand brand: 6786 :return: Brand 6787 If the method is called asynchronously, 6788 returns the request thread. 6789 """ 6790 kwargs['_return_http_data_only'] = True 6791 if kwargs.get('callback'): 6792 return self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6793 else: 6794 (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6795 return data 6796 6797 def update_brand_with_http_info(self, account_id, brand_id, **kwargs): 6798 """ 6799 Updates an existing brand. 6800 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**). 6801 This method makes a synchronous HTTP request by default. To make an 6802 asynchronous HTTP request, please define a `callback` function 6803 to be invoked when receiving the response. 6804 >>> def callback_function(response): 6805 >>> pprint(response) 6806 >>> 6807 >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function) 6808 6809 :param callback function: The callback function 6810 for asynchronous request. (optional) 6811 :param str account_id: The external account number (int) or account ID Guid. (required) 6812 :param str brand_id: The unique identifier of a brand. (required) 6813 :param str replace_brand: 6814 :param Brand brand: 6815 :return: Brand 6816 If the method is called asynchronously, 6817 returns the request thread. 6818 """ 6819 6820 all_params = ['account_id', 'brand_id', 'replace_brand', 'brand'] 6821 all_params.append('callback') 6822 all_params.append('_return_http_data_only') 6823 all_params.append('_preload_content') 6824 all_params.append('_request_timeout') 6825 6826 params = locals() 6827 for key, val in iteritems(params['kwargs']): 6828 if key not in all_params: 6829 raise TypeError( 6830 "Got an unexpected keyword argument '%s'" 6831 " to method update_brand" % key 6832 ) 6833 params[key] = val 6834 del params['kwargs'] 6835 # verify the required parameter 'account_id' is set 6836 if ('account_id' not in params) or (params['account_id'] is None): 6837 raise ValueError("Missing the required parameter `account_id` when calling `update_brand`") 6838 # verify the required parameter 'brand_id' is set 6839 if ('brand_id' not in params) or (params['brand_id'] is None): 6840 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`") 6841 6842 6843 collection_formats = {} 6844 6845 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 6846 path_params = {} 6847 if 'account_id' in params: 6848 path_params['accountId'] = params['account_id'] 6849 if 'brand_id' in params: 6850 path_params['brandId'] = params['brand_id'] 6851 6852 query_params = {} 6853 if 'replace_brand' in params: 6854 query_params['replace_brand'] = params['replace_brand'] 6855 6856 header_params = {} 6857 6858 form_params = [] 6859 local_var_files = {} 6860 6861 body_params = None 6862 if 'brand' in params: 6863 body_params = params['brand'] 6864 # HTTP header `Accept` 6865 header_params['Accept'] = self.api_client.\ 6866 select_header_accept(['application/json']) 6867 6868 # Authentication setting 6869 auth_settings = [] 6870 6871 return self.api_client.call_api(resource_path, 'PUT', 6872 path_params, 6873 query_params, 6874 header_params, 6875 body=body_params, 6876 post_params=form_params, 6877 files=local_var_files, 6878 response_type='Brand', 6879 auth_settings=auth_settings, 6880 callback=params.get('callback'), 6881 _return_http_data_only=params.get('_return_http_data_only'), 6882 _preload_content=params.get('_preload_content', True), 6883 _request_timeout=params.get('_request_timeout'), 6884 collection_formats=collection_formats) 6885 6886 def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6887 """ 6888 Put one branding logo. 6889 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**). 6890 This method makes a synchronous HTTP request by default. To make an 6891 asynchronous HTTP request, please define a `callback` function 6892 to be invoked when receiving the response. 6893 >>> def callback_function(response): 6894 >>> pprint(response) 6895 >>> 6896 >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6897 6898 :param callback function: The callback function 6899 for asynchronous request. (optional) 6900 :param str account_id: The external account number (int) or account ID GUID. (required) 6901 :param str brand_id: The ID of the brand. (required) 6902 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6903 :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) 6904 :return: None 6905 If the method is called asynchronously, 6906 returns the request thread. 6907 """ 6908 kwargs['_return_http_data_only'] = True 6909 if kwargs.get('callback'): 6910 return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6911 else: 6912 (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6913 return data 6914 6915 def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6916 """ 6917 Put one branding logo. 6918 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**). 6919 This method makes a synchronous HTTP request by default. To make an 6920 asynchronous HTTP request, please define a `callback` function 6921 to be invoked when receiving the response. 6922 >>> def callback_function(response): 6923 >>> pprint(response) 6924 >>> 6925 >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6926 6927 :param callback function: The callback function 6928 for asynchronous request. (optional) 6929 :param str account_id: The external account number (int) or account ID GUID. (required) 6930 :param str brand_id: The ID of the brand. (required) 6931 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6932 :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) 6933 :return: None 6934 If the method is called asynchronously, 6935 returns the request thread. 6936 """ 6937 6938 all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes'] 6939 all_params.append('callback') 6940 all_params.append('_return_http_data_only') 6941 all_params.append('_preload_content') 6942 all_params.append('_request_timeout') 6943 6944 params = locals() 6945 for key, val in iteritems(params['kwargs']): 6946 if key not in all_params: 6947 raise TypeError( 6948 "Got an unexpected keyword argument '%s'" 6949 " to method update_brand_logo_by_type" % key 6950 ) 6951 params[key] = val 6952 del params['kwargs'] 6953 # verify the required parameter 'account_id' is set 6954 if ('account_id' not in params) or (params['account_id'] is None): 6955 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`") 6956 # verify the required parameter 'brand_id' is set 6957 if ('brand_id' not in params) or (params['brand_id'] is None): 6958 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`") 6959 # verify the required parameter 'logo_type' is set 6960 if ('logo_type' not in params) or (params['logo_type'] is None): 6961 raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`") 6962 # verify the required parameter 'logo_file_bytes' is set 6963 if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None): 6964 raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`") 6965 6966 6967 collection_formats = {} 6968 6969 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 6970 path_params = {} 6971 if 'account_id' in params: 6972 path_params['accountId'] = params['account_id'] 6973 if 'brand_id' in params: 6974 path_params['brandId'] = params['brand_id'] 6975 if 'logo_type' in params: 6976 path_params['logoType'] = params['logo_type'] 6977 6978 query_params = {} 6979 6980 header_params = {} 6981 6982 form_params = [] 6983 local_var_files = {} 6984 6985 body_params = None 6986 if 'logo_file_bytes' in params: 6987 body_params = params['logo_file_bytes'] 6988 # HTTP header `Accept` 6989 header_params['Accept'] = self.api_client.\ 6990 select_header_accept(['application/json']) 6991 6992 # HTTP header `Content-Type` 6993 header_params['Content-Type'] = self.api_client.\ 6994 select_header_content_type(['image/png']) 6995 6996 # Authentication setting 6997 auth_settings = [] 6998 6999 return self.api_client.call_api(resource_path, 'PUT', 7000 path_params, 7001 query_params, 7002 header_params, 7003 body=body_params, 7004 post_params=form_params, 7005 files=local_var_files, 7006 response_type=None, 7007 auth_settings=auth_settings, 7008 callback=params.get('callback'), 7009 _return_http_data_only=params.get('_return_http_data_only'), 7010 _preload_content=params.get('_preload_content', True), 7011 _request_timeout=params.get('_request_timeout'), 7012 collection_formats=collection_formats) 7013 7014 def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7015 """ 7016 Uploads a branding resource file. 7017 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. 7018 This method makes a synchronous HTTP request by default. To make an 7019 asynchronous HTTP request, please define a `callback` function 7020 to be invoked when receiving the response. 7021 >>> def callback_function(response): 7022 >>> pprint(response) 7023 >>> 7024 >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7025 7026 :param callback function: The callback function 7027 for asynchronous request. (optional) 7028 :param str account_id: The external account number (int) or account ID GUID. (required) 7029 :param str brand_id: The ID of the brand. (required) 7030 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7031 :param file file_xml: Brand resource XML file. (required) 7032 :return: BrandResources 7033 If the method is called asynchronously, 7034 returns the request thread. 7035 """ 7036 kwargs['_return_http_data_only'] = True 7037 if kwargs.get('callback'): 7038 return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7039 else: 7040 (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7041 return data 7042 7043 def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7044 """ 7045 Uploads a branding resource file. 7046 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. 7047 This method makes a synchronous HTTP request by default. To make an 7048 asynchronous HTTP request, please define a `callback` function 7049 to be invoked when receiving the response. 7050 >>> def callback_function(response): 7051 >>> pprint(response) 7052 >>> 7053 >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7054 7055 :param callback function: The callback function 7056 for asynchronous request. (optional) 7057 :param str account_id: The external account number (int) or account ID GUID. (required) 7058 :param str brand_id: The ID of the brand. (required) 7059 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7060 :param file file_xml: Brand resource XML file. (required) 7061 :return: BrandResources 7062 If the method is called asynchronously, 7063 returns the request thread. 7064 """ 7065 7066 all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml'] 7067 all_params.append('callback') 7068 all_params.append('_return_http_data_only') 7069 all_params.append('_preload_content') 7070 all_params.append('_request_timeout') 7071 7072 params = locals() 7073 for key, val in iteritems(params['kwargs']): 7074 if key not in all_params: 7075 raise TypeError( 7076 "Got an unexpected keyword argument '%s'" 7077 " to method update_brand_resources_by_content_type" % key 7078 ) 7079 params[key] = val 7080 del params['kwargs'] 7081 # verify the required parameter 'account_id' is set 7082 if ('account_id' not in params) or (params['account_id'] is None): 7083 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`") 7084 # verify the required parameter 'brand_id' is set 7085 if ('brand_id' not in params) or (params['brand_id'] is None): 7086 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`") 7087 # verify the required parameter 'resource_content_type' is set 7088 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 7089 raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`") 7090 # verify the required parameter 'file_xml' is set 7091 if ('file_xml' not in params) or (params['file_xml'] is None): 7092 raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`") 7093 7094 7095 collection_formats = {} 7096 7097 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 7098 path_params = {} 7099 if 'account_id' in params: 7100 path_params['accountId'] = params['account_id'] 7101 if 'brand_id' in params: 7102 path_params['brandId'] = params['brand_id'] 7103 if 'resource_content_type' in params: 7104 path_params['resourceContentType'] = params['resource_content_type'] 7105 7106 query_params = {} 7107 7108 header_params = {} 7109 7110 form_params = [] 7111 local_var_files = {} 7112 if 'file_xml' in params: 7113 local_var_files['file.xml'] = params['file_xml'] 7114 7115 body_params = None 7116 # HTTP header `Accept` 7117 header_params['Accept'] = self.api_client.\ 7118 select_header_accept(['application/json']) 7119 7120 # HTTP header `Content-Type` 7121 header_params['Content-Type'] = self.api_client.\ 7122 select_header_content_type(['multipart/form-data']) 7123 7124 # Authentication setting 7125 auth_settings = [] 7126 7127 return self.api_client.call_api(resource_path, 'PUT', 7128 path_params, 7129 query_params, 7130 header_params, 7131 body=body_params, 7132 post_params=form_params, 7133 files=local_var_files, 7134 response_type='BrandResources', 7135 auth_settings=auth_settings, 7136 callback=params.get('callback'), 7137 _return_http_data_only=params.get('_return_http_data_only'), 7138 _preload_content=params.get('_preload_content', True), 7139 _request_timeout=params.get('_request_timeout'), 7140 collection_formats=collection_formats) 7141 7142 def update_consumer_disclosure(self, account_id, lang_code, **kwargs): 7143 """ 7144 Update Consumer Disclosure. 7145 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. 7146 This method makes a synchronous HTTP request by default. To make an 7147 asynchronous HTTP request, please define a `callback` function 7148 to be invoked when receiving the response. 7149 >>> def callback_function(response): 7150 >>> pprint(response) 7151 >>> 7152 >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function) 7153 7154 :param callback function: The callback function 7155 for asynchronous request. (optional) 7156 :param str account_id: The external account number (int) or account ID Guid. (required) 7157 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 7158 :param str include_metadata: 7159 :param ConsumerDisclosure consumer_disclosure: 7160 :return: ConsumerDisclosure 7161 If the method is called asynchronously, 7162 returns the request thread. 7163 """ 7164 kwargs['_return_http_data_only'] = True 7165 if kwargs.get('callback'): 7166 return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7167 else: 7168 (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7169 return data 7170 7171 def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 7172 """ 7173 Update Consumer Disclosure. 7174 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. 7175 This method makes a synchronous HTTP request by default. To make an 7176 asynchronous HTTP request, please define a `callback` function 7177 to be invoked when receiving the response. 7178 >>> def callback_function(response): 7179 >>> pprint(response) 7180 >>> 7181 >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 7182 7183 :param callback function: The callback function 7184 for asynchronous request. (optional) 7185 :param str account_id: The external account number (int) or account ID Guid. (required) 7186 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 7187 :param str include_metadata: 7188 :param ConsumerDisclosure consumer_disclosure: 7189 :return: ConsumerDisclosure 7190 If the method is called asynchronously, 7191 returns the request thread. 7192 """ 7193 7194 all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure'] 7195 all_params.append('callback') 7196 all_params.append('_return_http_data_only') 7197 all_params.append('_preload_content') 7198 all_params.append('_request_timeout') 7199 7200 params = locals() 7201 for key, val in iteritems(params['kwargs']): 7202 if key not in all_params: 7203 raise TypeError( 7204 "Got an unexpected keyword argument '%s'" 7205 " to method update_consumer_disclosure" % key 7206 ) 7207 params[key] = val 7208 del params['kwargs'] 7209 # verify the required parameter 'account_id' is set 7210 if ('account_id' not in params) or (params['account_id'] is None): 7211 raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`") 7212 # verify the required parameter 'lang_code' is set 7213 if ('lang_code' not in params) or (params['lang_code'] is None): 7214 raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`") 7215 7216 7217 collection_formats = {} 7218 7219 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 7220 path_params = {} 7221 if 'account_id' in params: 7222 path_params['accountId'] = params['account_id'] 7223 if 'lang_code' in params: 7224 path_params['langCode'] = params['lang_code'] 7225 7226 query_params = {} 7227 if 'include_metadata' in params: 7228 query_params['include_metadata'] = params['include_metadata'] 7229 7230 header_params = {} 7231 7232 form_params = [] 7233 local_var_files = {} 7234 7235 body_params = None 7236 if 'consumer_disclosure' in params: 7237 body_params = params['consumer_disclosure'] 7238 # HTTP header `Accept` 7239 header_params['Accept'] = self.api_client.\ 7240 select_header_accept(['application/json']) 7241 7242 # Authentication setting 7243 auth_settings = [] 7244 7245 return self.api_client.call_api(resource_path, 'PUT', 7246 path_params, 7247 query_params, 7248 header_params, 7249 body=body_params, 7250 post_params=form_params, 7251 files=local_var_files, 7252 response_type='ConsumerDisclosure', 7253 auth_settings=auth_settings, 7254 callback=params.get('callback'), 7255 _return_http_data_only=params.get('_return_http_data_only'), 7256 _preload_content=params.get('_preload_content', True), 7257 _request_timeout=params.get('_request_timeout'), 7258 collection_formats=collection_formats) 7259 7260 def update_custom_field(self, account_id, custom_field_id, **kwargs): 7261 """ 7262 Updates an existing account custom field. 7263 This method updates an existing account custom field. 7264 This method makes a synchronous HTTP request by default. To make an 7265 asynchronous HTTP request, please define a `callback` function 7266 to be invoked when receiving the response. 7267 >>> def callback_function(response): 7268 >>> pprint(response) 7269 >>> 7270 >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function) 7271 7272 :param callback function: The callback function 7273 for asynchronous request. (optional) 7274 :param str account_id: The external account number (int) or account ID Guid. (required) 7275 :param str custom_field_id: (required) 7276 :param str apply_to_templates: 7277 :param CustomField custom_field: 7278 :return: CustomFields 7279 If the method is called asynchronously, 7280 returns the request thread. 7281 """ 7282 kwargs['_return_http_data_only'] = True 7283 if kwargs.get('callback'): 7284 return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7285 else: 7286 (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7287 return data 7288 7289 def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 7290 """ 7291 Updates an existing account custom field. 7292 This method updates an existing account custom field. 7293 This method makes a synchronous HTTP request by default. To make an 7294 asynchronous HTTP request, please define a `callback` function 7295 to be invoked when receiving the response. 7296 >>> def callback_function(response): 7297 >>> pprint(response) 7298 >>> 7299 >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 7300 7301 :param callback function: The callback function 7302 for asynchronous request. (optional) 7303 :param str account_id: The external account number (int) or account ID Guid. (required) 7304 :param str custom_field_id: (required) 7305 :param str apply_to_templates: 7306 :param CustomField custom_field: 7307 :return: CustomFields 7308 If the method is called asynchronously, 7309 returns the request thread. 7310 """ 7311 7312 all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field'] 7313 all_params.append('callback') 7314 all_params.append('_return_http_data_only') 7315 all_params.append('_preload_content') 7316 all_params.append('_request_timeout') 7317 7318 params = locals() 7319 for key, val in iteritems(params['kwargs']): 7320 if key not in all_params: 7321 raise TypeError( 7322 "Got an unexpected keyword argument '%s'" 7323 " to method update_custom_field" % key 7324 ) 7325 params[key] = val 7326 del params['kwargs'] 7327 # verify the required parameter 'account_id' is set 7328 if ('account_id' not in params) or (params['account_id'] is None): 7329 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`") 7330 # verify the required parameter 'custom_field_id' is set 7331 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 7332 raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`") 7333 7334 7335 collection_formats = {} 7336 7337 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 7338 path_params = {} 7339 if 'account_id' in params: 7340 path_params['accountId'] = params['account_id'] 7341 if 'custom_field_id' in params: 7342 path_params['customFieldId'] = params['custom_field_id'] 7343 7344 query_params = {} 7345 if 'apply_to_templates' in params: 7346 query_params['apply_to_templates'] = params['apply_to_templates'] 7347 7348 header_params = {} 7349 7350 form_params = [] 7351 local_var_files = {} 7352 7353 body_params = None 7354 if 'custom_field' in params: 7355 body_params = params['custom_field'] 7356 # HTTP header `Accept` 7357 header_params['Accept'] = self.api_client.\ 7358 select_header_accept(['application/json']) 7359 7360 # Authentication setting 7361 auth_settings = [] 7362 7363 return self.api_client.call_api(resource_path, 'PUT', 7364 path_params, 7365 query_params, 7366 header_params, 7367 body=body_params, 7368 post_params=form_params, 7369 files=local_var_files, 7370 response_type='CustomFields', 7371 auth_settings=auth_settings, 7372 callback=params.get('callback'), 7373 _return_http_data_only=params.get('_return_http_data_only'), 7374 _preload_content=params.get('_preload_content', True), 7375 _request_timeout=params.get('_request_timeout'), 7376 collection_formats=collection_formats) 7377 7378 def update_e_note_configuration(self, account_id, **kwargs): 7379 """ 7380 Updates configuration information for the eNote eOriginal integration. 7381 7382 This method makes a synchronous HTTP request by default. To make an 7383 asynchronous HTTP request, please define a `callback` function 7384 to be invoked when receiving the response. 7385 >>> def callback_function(response): 7386 >>> pprint(response) 7387 >>> 7388 >>> thread = api.update_e_note_configuration(account_id, callback=callback_function) 7389 7390 :param callback function: The callback function 7391 for asynchronous request. (optional) 7392 :param str account_id: The external account number (int) or account ID Guid. (required) 7393 :param ENoteConfiguration e_note_configuration: 7394 :return: ENoteConfiguration 7395 If the method is called asynchronously, 7396 returns the request thread. 7397 """ 7398 kwargs['_return_http_data_only'] = True 7399 if kwargs.get('callback'): 7400 return self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7401 else: 7402 (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7403 return data 7404 7405 def update_e_note_configuration_with_http_info(self, account_id, **kwargs): 7406 """ 7407 Updates configuration information for the eNote eOriginal integration. 7408 7409 This method makes a synchronous HTTP request by default. To make an 7410 asynchronous HTTP request, please define a `callback` function 7411 to be invoked when receiving the response. 7412 >>> def callback_function(response): 7413 >>> pprint(response) 7414 >>> 7415 >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function) 7416 7417 :param callback function: The callback function 7418 for asynchronous request. (optional) 7419 :param str account_id: The external account number (int) or account ID Guid. (required) 7420 :param ENoteConfiguration e_note_configuration: 7421 :return: ENoteConfiguration 7422 If the method is called asynchronously, 7423 returns the request thread. 7424 """ 7425 7426 all_params = ['account_id', 'e_note_configuration'] 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_e_note_configuration" % 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_e_note_configuration`") 7444 7445 7446 collection_formats = {} 7447 7448 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 7449 path_params = {} 7450 if 'account_id' in params: 7451 path_params['accountId'] = params['account_id'] 7452 7453 query_params = {} 7454 7455 header_params = {} 7456 7457 form_params = [] 7458 local_var_files = {} 7459 7460 body_params = None 7461 if 'e_note_configuration' in params: 7462 body_params = params['e_note_configuration'] 7463 # HTTP header `Accept` 7464 header_params['Accept'] = self.api_client.\ 7465 select_header_accept(['application/json']) 7466 7467 # Authentication setting 7468 auth_settings = [] 7469 7470 return self.api_client.call_api(resource_path, 'PUT', 7471 path_params, 7472 query_params, 7473 header_params, 7474 body=body_params, 7475 post_params=form_params, 7476 files=local_var_files, 7477 response_type='ENoteConfiguration', 7478 auth_settings=auth_settings, 7479 callback=params.get('callback'), 7480 _return_http_data_only=params.get('_return_http_data_only'), 7481 _preload_content=params.get('_preload_content', True), 7482 _request_timeout=params.get('_request_timeout'), 7483 collection_formats=collection_formats) 7484 7485 def update_envelope_purge_configuration(self, account_id, **kwargs): 7486 """ 7487 Updates envelope purge configuration. 7488 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). 7489 This method makes a synchronous HTTP request by default. To make an 7490 asynchronous HTTP request, please define a `callback` function 7491 to be invoked when receiving the response. 7492 >>> def callback_function(response): 7493 >>> pprint(response) 7494 >>> 7495 >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function) 7496 7497 :param callback function: The callback function 7498 for asynchronous request. (optional) 7499 :param str account_id: The external account number (int) or account ID Guid. (required) 7500 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7501 :return: EnvelopePurgeConfiguration 7502 If the method is called asynchronously, 7503 returns the request thread. 7504 """ 7505 kwargs['_return_http_data_only'] = True 7506 if kwargs.get('callback'): 7507 return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7508 else: 7509 (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7510 return data 7511 7512 def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 7513 """ 7514 Updates envelope purge configuration. 7515 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). 7516 This method makes a synchronous HTTP request by default. To make an 7517 asynchronous HTTP request, please define a `callback` function 7518 to be invoked when receiving the response. 7519 >>> def callback_function(response): 7520 >>> pprint(response) 7521 >>> 7522 >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 7523 7524 :param callback function: The callback function 7525 for asynchronous request. (optional) 7526 :param str account_id: The external account number (int) or account ID Guid. (required) 7527 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7528 :return: EnvelopePurgeConfiguration 7529 If the method is called asynchronously, 7530 returns the request thread. 7531 """ 7532 7533 all_params = ['account_id', 'envelope_purge_configuration'] 7534 all_params.append('callback') 7535 all_params.append('_return_http_data_only') 7536 all_params.append('_preload_content') 7537 all_params.append('_request_timeout') 7538 7539 params = locals() 7540 for key, val in iteritems(params['kwargs']): 7541 if key not in all_params: 7542 raise TypeError( 7543 "Got an unexpected keyword argument '%s'" 7544 " to method update_envelope_purge_configuration" % key 7545 ) 7546 params[key] = val 7547 del params['kwargs'] 7548 # verify the required parameter 'account_id' is set 7549 if ('account_id' not in params) or (params['account_id'] is None): 7550 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`") 7551 7552 7553 collection_formats = {} 7554 7555 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 7556 path_params = {} 7557 if 'account_id' in params: 7558 path_params['accountId'] = params['account_id'] 7559 7560 query_params = {} 7561 7562 header_params = {} 7563 7564 form_params = [] 7565 local_var_files = {} 7566 7567 body_params = None 7568 if 'envelope_purge_configuration' in params: 7569 body_params = params['envelope_purge_configuration'] 7570 # HTTP header `Accept` 7571 header_params['Accept'] = self.api_client.\ 7572 select_header_accept(['application/json']) 7573 7574 # Authentication setting 7575 auth_settings = [] 7576 7577 return self.api_client.call_api(resource_path, 'PUT', 7578 path_params, 7579 query_params, 7580 header_params, 7581 body=body_params, 7582 post_params=form_params, 7583 files=local_var_files, 7584 response_type='EnvelopePurgeConfiguration', 7585 auth_settings=auth_settings, 7586 callback=params.get('callback'), 7587 _return_http_data_only=params.get('_return_http_data_only'), 7588 _preload_content=params.get('_preload_content', True), 7589 _request_timeout=params.get('_request_timeout'), 7590 collection_formats=collection_formats) 7591 7592 def update_favorite_template(self, account_id, **kwargs): 7593 """ 7594 Favorites a template 7595 7596 This method makes a synchronous HTTP request by default. To make an 7597 asynchronous HTTP request, please define a `callback` function 7598 to be invoked when receiving the response. 7599 >>> def callback_function(response): 7600 >>> pprint(response) 7601 >>> 7602 >>> thread = api.update_favorite_template(account_id, callback=callback_function) 7603 7604 :param callback function: The callback function 7605 for asynchronous request. (optional) 7606 :param str account_id: The external account number (int) or account ID Guid. (required) 7607 :param FavoriteTemplatesInfo favorite_templates_info: 7608 :return: FavoriteTemplatesInfo 7609 If the method is called asynchronously, 7610 returns the request thread. 7611 """ 7612 kwargs['_return_http_data_only'] = True 7613 if kwargs.get('callback'): 7614 return self.update_favorite_template_with_http_info(account_id, **kwargs) 7615 else: 7616 (data) = self.update_favorite_template_with_http_info(account_id, **kwargs) 7617 return data 7618 7619 def update_favorite_template_with_http_info(self, account_id, **kwargs): 7620 """ 7621 Favorites a template 7622 7623 This method makes a synchronous HTTP request by default. To make an 7624 asynchronous HTTP request, please define a `callback` function 7625 to be invoked when receiving the response. 7626 >>> def callback_function(response): 7627 >>> pprint(response) 7628 >>> 7629 >>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function) 7630 7631 :param callback function: The callback function 7632 for asynchronous request. (optional) 7633 :param str account_id: The external account number (int) or account ID Guid. (required) 7634 :param FavoriteTemplatesInfo favorite_templates_info: 7635 :return: FavoriteTemplatesInfo 7636 If the method is called asynchronously, 7637 returns the request thread. 7638 """ 7639 7640 all_params = ['account_id', 'favorite_templates_info'] 7641 all_params.append('callback') 7642 all_params.append('_return_http_data_only') 7643 all_params.append('_preload_content') 7644 all_params.append('_request_timeout') 7645 7646 params = locals() 7647 for key, val in iteritems(params['kwargs']): 7648 if key not in all_params: 7649 raise TypeError( 7650 "Got an unexpected keyword argument '%s'" 7651 " to method update_favorite_template" % key 7652 ) 7653 params[key] = val 7654 del params['kwargs'] 7655 # verify the required parameter 'account_id' is set 7656 if ('account_id' not in params) or (params['account_id'] is None): 7657 raise ValueError("Missing the required parameter `account_id` when calling `update_favorite_template`") 7658 7659 7660 collection_formats = {} 7661 7662 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 7663 path_params = {} 7664 if 'account_id' in params: 7665 path_params['accountId'] = params['account_id'] 7666 7667 query_params = {} 7668 7669 header_params = {} 7670 7671 form_params = [] 7672 local_var_files = {} 7673 7674 body_params = None 7675 if 'favorite_templates_info' in params: 7676 body_params = params['favorite_templates_info'] 7677 # HTTP header `Accept` 7678 header_params['Accept'] = self.api_client.\ 7679 select_header_accept(['application/json']) 7680 7681 # Authentication setting 7682 auth_settings = [] 7683 7684 return self.api_client.call_api(resource_path, 'PUT', 7685 path_params, 7686 query_params, 7687 header_params, 7688 body=body_params, 7689 post_params=form_params, 7690 files=local_var_files, 7691 response_type='FavoriteTemplatesInfo', 7692 auth_settings=auth_settings, 7693 callback=params.get('callback'), 7694 _return_http_data_only=params.get('_return_http_data_only'), 7695 _preload_content=params.get('_preload_content', True), 7696 _request_timeout=params.get('_request_timeout'), 7697 collection_formats=collection_formats) 7698 7699 def update_notification_defaults(self, account_id, **kwargs): 7700 """ 7701 Updates default user level settings for a specified account 7702 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7703 This method makes a synchronous HTTP request by default. To make an 7704 asynchronous HTTP request, please define a `callback` function 7705 to be invoked when receiving the response. 7706 >>> def callback_function(response): 7707 >>> pprint(response) 7708 >>> 7709 >>> thread = api.update_notification_defaults(account_id, callback=callback_function) 7710 7711 :param callback function: The callback function 7712 for asynchronous request. (optional) 7713 :param str account_id: The external account number (int) or account ID Guid. (required) 7714 :param NotificationDefaults notification_defaults: 7715 :return: NotificationDefaults 7716 If the method is called asynchronously, 7717 returns the request thread. 7718 """ 7719 kwargs['_return_http_data_only'] = True 7720 if kwargs.get('callback'): 7721 return self.update_notification_defaults_with_http_info(account_id, **kwargs) 7722 else: 7723 (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs) 7724 return data 7725 7726 def update_notification_defaults_with_http_info(self, account_id, **kwargs): 7727 """ 7728 Updates default user level settings for a specified account 7729 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7730 This method makes a synchronous HTTP request by default. To make an 7731 asynchronous HTTP request, please define a `callback` function 7732 to be invoked when receiving the response. 7733 >>> def callback_function(response): 7734 >>> pprint(response) 7735 >>> 7736 >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function) 7737 7738 :param callback function: The callback function 7739 for asynchronous request. (optional) 7740 :param str account_id: The external account number (int) or account ID Guid. (required) 7741 :param NotificationDefaults notification_defaults: 7742 :return: NotificationDefaults 7743 If the method is called asynchronously, 7744 returns the request thread. 7745 """ 7746 7747 all_params = ['account_id', 'notification_defaults'] 7748 all_params.append('callback') 7749 all_params.append('_return_http_data_only') 7750 all_params.append('_preload_content') 7751 all_params.append('_request_timeout') 7752 7753 params = locals() 7754 for key, val in iteritems(params['kwargs']): 7755 if key not in all_params: 7756 raise TypeError( 7757 "Got an unexpected keyword argument '%s'" 7758 " to method update_notification_defaults" % key 7759 ) 7760 params[key] = val 7761 del params['kwargs'] 7762 # verify the required parameter 'account_id' is set 7763 if ('account_id' not in params) or (params['account_id'] is None): 7764 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`") 7765 7766 7767 collection_formats = {} 7768 7769 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 7770 path_params = {} 7771 if 'account_id' in params: 7772 path_params['accountId'] = params['account_id'] 7773 7774 query_params = {} 7775 7776 header_params = {} 7777 7778 form_params = [] 7779 local_var_files = {} 7780 7781 body_params = None 7782 if 'notification_defaults' in params: 7783 body_params = params['notification_defaults'] 7784 # HTTP header `Accept` 7785 header_params['Accept'] = self.api_client.\ 7786 select_header_accept(['application/json']) 7787 7788 # Authentication setting 7789 auth_settings = [] 7790 7791 return self.api_client.call_api(resource_path, 'PUT', 7792 path_params, 7793 query_params, 7794 header_params, 7795 body=body_params, 7796 post_params=form_params, 7797 files=local_var_files, 7798 response_type='NotificationDefaults', 7799 auth_settings=auth_settings, 7800 callback=params.get('callback'), 7801 _return_http_data_only=params.get('_return_http_data_only'), 7802 _preload_content=params.get('_preload_content', True), 7803 _request_timeout=params.get('_request_timeout'), 7804 collection_formats=collection_formats) 7805 7806 def update_password_rules(self, account_id, **kwargs): 7807 """ 7808 Update the password rules 7809 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7810 This method makes a synchronous HTTP request by default. To make an 7811 asynchronous HTTP request, please define a `callback` function 7812 to be invoked when receiving the response. 7813 >>> def callback_function(response): 7814 >>> pprint(response) 7815 >>> 7816 >>> thread = api.update_password_rules(account_id, callback=callback_function) 7817 7818 :param callback function: The callback function 7819 for asynchronous request. (optional) 7820 :param str account_id: The external account number (int) or account ID Guid. (required) 7821 :param AccountPasswordRules account_password_rules: 7822 :return: AccountPasswordRules 7823 If the method is called asynchronously, 7824 returns the request thread. 7825 """ 7826 kwargs['_return_http_data_only'] = True 7827 if kwargs.get('callback'): 7828 return self.update_password_rules_with_http_info(account_id, **kwargs) 7829 else: 7830 (data) = self.update_password_rules_with_http_info(account_id, **kwargs) 7831 return data 7832 7833 def update_password_rules_with_http_info(self, account_id, **kwargs): 7834 """ 7835 Update the password rules 7836 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7837 This method makes a synchronous HTTP request by default. To make an 7838 asynchronous HTTP request, please define a `callback` function 7839 to be invoked when receiving the response. 7840 >>> def callback_function(response): 7841 >>> pprint(response) 7842 >>> 7843 >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function) 7844 7845 :param callback function: The callback function 7846 for asynchronous request. (optional) 7847 :param str account_id: The external account number (int) or account ID Guid. (required) 7848 :param AccountPasswordRules account_password_rules: 7849 :return: AccountPasswordRules 7850 If the method is called asynchronously, 7851 returns the request thread. 7852 """ 7853 7854 all_params = ['account_id', 'account_password_rules'] 7855 all_params.append('callback') 7856 all_params.append('_return_http_data_only') 7857 all_params.append('_preload_content') 7858 all_params.append('_request_timeout') 7859 7860 params = locals() 7861 for key, val in iteritems(params['kwargs']): 7862 if key not in all_params: 7863 raise TypeError( 7864 "Got an unexpected keyword argument '%s'" 7865 " to method update_password_rules" % key 7866 ) 7867 params[key] = val 7868 del params['kwargs'] 7869 # verify the required parameter 'account_id' is set 7870 if ('account_id' not in params) or (params['account_id'] is None): 7871 raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`") 7872 7873 7874 collection_formats = {} 7875 7876 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 7877 path_params = {} 7878 if 'account_id' in params: 7879 path_params['accountId'] = params['account_id'] 7880 7881 query_params = {} 7882 7883 header_params = {} 7884 7885 form_params = [] 7886 local_var_files = {} 7887 7888 body_params = None 7889 if 'account_password_rules' in params: 7890 body_params = params['account_password_rules'] 7891 # HTTP header `Accept` 7892 header_params['Accept'] = self.api_client.\ 7893 select_header_accept(['application/json']) 7894 7895 # Authentication setting 7896 auth_settings = [] 7897 7898 return self.api_client.call_api(resource_path, 'PUT', 7899 path_params, 7900 query_params, 7901 header_params, 7902 body=body_params, 7903 post_params=form_params, 7904 files=local_var_files, 7905 response_type='AccountPasswordRules', 7906 auth_settings=auth_settings, 7907 callback=params.get('callback'), 7908 _return_http_data_only=params.get('_return_http_data_only'), 7909 _preload_content=params.get('_preload_content', True), 7910 _request_timeout=params.get('_request_timeout'), 7911 collection_formats=collection_formats) 7912 7913 def update_permission_profile(self, account_id, permission_profile_id, **kwargs): 7914 """ 7915 Updates a permission profile within the specified account. 7916 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7917 This method makes a synchronous HTTP request by default. To make an 7918 asynchronous HTTP request, please define a `callback` function 7919 to be invoked when receiving the response. 7920 >>> def callback_function(response): 7921 >>> pprint(response) 7922 >>> 7923 >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function) 7924 7925 :param callback function: The callback function 7926 for asynchronous request. (optional) 7927 :param str account_id: The external account number (int) or account ID Guid. (required) 7928 :param str permission_profile_id: (required) 7929 :param str include: 7930 :param PermissionProfile permission_profile: 7931 :return: PermissionProfile 7932 If the method is called asynchronously, 7933 returns the request thread. 7934 """ 7935 kwargs['_return_http_data_only'] = True 7936 if kwargs.get('callback'): 7937 return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7938 else: 7939 (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7940 return data 7941 7942 def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 7943 """ 7944 Updates a permission profile within the specified account. 7945 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7946 This method makes a synchronous HTTP request by default. To make an 7947 asynchronous HTTP request, please define a `callback` function 7948 to be invoked when receiving the response. 7949 >>> def callback_function(response): 7950 >>> pprint(response) 7951 >>> 7952 >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 7953 7954 :param callback function: The callback function 7955 for asynchronous request. (optional) 7956 :param str account_id: The external account number (int) or account ID Guid. (required) 7957 :param str permission_profile_id: (required) 7958 :param str include: 7959 :param PermissionProfile permission_profile: 7960 :return: PermissionProfile 7961 If the method is called asynchronously, 7962 returns the request thread. 7963 """ 7964 7965 all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile'] 7966 all_params.append('callback') 7967 all_params.append('_return_http_data_only') 7968 all_params.append('_preload_content') 7969 all_params.append('_request_timeout') 7970 7971 params = locals() 7972 for key, val in iteritems(params['kwargs']): 7973 if key not in all_params: 7974 raise TypeError( 7975 "Got an unexpected keyword argument '%s'" 7976 " to method update_permission_profile" % key 7977 ) 7978 params[key] = val 7979 del params['kwargs'] 7980 # verify the required parameter 'account_id' is set 7981 if ('account_id' not in params) or (params['account_id'] is None): 7982 raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`") 7983 # verify the required parameter 'permission_profile_id' is set 7984 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 7985 raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`") 7986 7987 7988 collection_formats = {} 7989 7990 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 7991 path_params = {} 7992 if 'account_id' in params: 7993 path_params['accountId'] = params['account_id'] 7994 if 'permission_profile_id' in params: 7995 path_params['permissionProfileId'] = params['permission_profile_id'] 7996 7997 query_params = {} 7998 if 'include' in params: 7999 query_params['include'] = params['include'] 8000 8001 header_params = {} 8002 8003 form_params = [] 8004 local_var_files = {} 8005 8006 body_params = None 8007 if 'permission_profile' in params: 8008 body_params = params['permission_profile'] 8009 # HTTP header `Accept` 8010 header_params['Accept'] = self.api_client.\ 8011 select_header_accept(['application/json']) 8012 8013 # Authentication setting 8014 auth_settings = [] 8015 8016 return self.api_client.call_api(resource_path, 'PUT', 8017 path_params, 8018 query_params, 8019 header_params, 8020 body=body_params, 8021 post_params=form_params, 8022 files=local_var_files, 8023 response_type='PermissionProfile', 8024 auth_settings=auth_settings, 8025 callback=params.get('callback'), 8026 _return_http_data_only=params.get('_return_http_data_only'), 8027 _preload_content=params.get('_preload_content', True), 8028 _request_timeout=params.get('_request_timeout'), 8029 collection_formats=collection_formats) 8030 8031 def update_settings(self, account_id, **kwargs): 8032 """ 8033 Updates the account settings for an account. 8034 Updates the account settings for the specified account. 8035 This method makes a synchronous HTTP request by default. To make an 8036 asynchronous HTTP request, please define a `callback` function 8037 to be invoked when receiving the response. 8038 >>> def callback_function(response): 8039 >>> pprint(response) 8040 >>> 8041 >>> thread = api.update_settings(account_id, callback=callback_function) 8042 8043 :param callback function: The callback function 8044 for asynchronous request. (optional) 8045 :param str account_id: The external account number (int) or account ID Guid. (required) 8046 :param AccountSettingsInformation account_settings_information: 8047 :return: None 8048 If the method is called asynchronously, 8049 returns the request thread. 8050 """ 8051 kwargs['_return_http_data_only'] = True 8052 if kwargs.get('callback'): 8053 return self.update_settings_with_http_info(account_id, **kwargs) 8054 else: 8055 (data) = self.update_settings_with_http_info(account_id, **kwargs) 8056 return data 8057 8058 def update_settings_with_http_info(self, account_id, **kwargs): 8059 """ 8060 Updates the account settings for an account. 8061 Updates the account settings for the specified account. 8062 This method makes a synchronous HTTP request by default. To make an 8063 asynchronous HTTP request, please define a `callback` function 8064 to be invoked when receiving the response. 8065 >>> def callback_function(response): 8066 >>> pprint(response) 8067 >>> 8068 >>> thread = api.update_settings_with_http_info(account_id, callback=callback_function) 8069 8070 :param callback function: The callback function 8071 for asynchronous request. (optional) 8072 :param str account_id: The external account number (int) or account ID Guid. (required) 8073 :param AccountSettingsInformation account_settings_information: 8074 :return: None 8075 If the method is called asynchronously, 8076 returns the request thread. 8077 """ 8078 8079 all_params = ['account_id', 'account_settings_information'] 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_settings" % 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_settings`") 8097 8098 8099 collection_formats = {} 8100 8101 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 8102 path_params = {} 8103 if 'account_id' in params: 8104 path_params['accountId'] = params['account_id'] 8105 8106 query_params = {} 8107 8108 header_params = {} 8109 8110 form_params = [] 8111 local_var_files = {} 8112 8113 body_params = None 8114 if 'account_settings_information' in params: 8115 body_params = params['account_settings_information'] 8116 # HTTP header `Accept` 8117 header_params['Accept'] = self.api_client.\ 8118 select_header_accept(['application/json']) 8119 8120 # Authentication setting 8121 auth_settings = [] 8122 8123 return self.api_client.call_api(resource_path, 'PUT', 8124 path_params, 8125 query_params, 8126 header_params, 8127 body=body_params, 8128 post_params=form_params, 8129 files=local_var_files, 8130 response_type=None, 8131 auth_settings=auth_settings, 8132 callback=params.get('callback'), 8133 _return_http_data_only=params.get('_return_http_data_only'), 8134 _preload_content=params.get('_preload_content', True), 8135 _request_timeout=params.get('_request_timeout'), 8136 collection_formats=collection_formats) 8137 8138 def update_shared_access(self, account_id, **kwargs): 8139 """ 8140 Reserved: Sets the shared access information for users. 8141 Reserved: Sets the shared access information for one or more users. 8142 This method makes a synchronous HTTP request by default. To make an 8143 asynchronous HTTP request, please define a `callback` function 8144 to be invoked when receiving the response. 8145 >>> def callback_function(response): 8146 >>> pprint(response) 8147 >>> 8148 >>> thread = api.update_shared_access(account_id, callback=callback_function) 8149 8150 :param callback function: The callback function 8151 for asynchronous request. (optional) 8152 :param str account_id: The external account number (int) or account ID Guid. (required) 8153 :param str item_type: 8154 :param str preserve_existing_shared_access: 8155 :param str user_ids: 8156 :param AccountSharedAccess account_shared_access: 8157 :return: AccountSharedAccess 8158 If the method is called asynchronously, 8159 returns the request thread. 8160 """ 8161 kwargs['_return_http_data_only'] = True 8162 if kwargs.get('callback'): 8163 return self.update_shared_access_with_http_info(account_id, **kwargs) 8164 else: 8165 (data) = self.update_shared_access_with_http_info(account_id, **kwargs) 8166 return data 8167 8168 def update_shared_access_with_http_info(self, account_id, **kwargs): 8169 """ 8170 Reserved: Sets the shared access information for users. 8171 Reserved: Sets the shared access information for one or more users. 8172 This method makes a synchronous HTTP request by default. To make an 8173 asynchronous HTTP request, please define a `callback` function 8174 to be invoked when receiving the response. 8175 >>> def callback_function(response): 8176 >>> pprint(response) 8177 >>> 8178 >>> thread = api.update_shared_access_with_http_info(account_id, callback=callback_function) 8179 8180 :param callback function: The callback function 8181 for asynchronous request. (optional) 8182 :param str account_id: The external account number (int) or account ID Guid. (required) 8183 :param str item_type: 8184 :param str preserve_existing_shared_access: 8185 :param str user_ids: 8186 :param AccountSharedAccess account_shared_access: 8187 :return: AccountSharedAccess 8188 If the method is called asynchronously, 8189 returns the request thread. 8190 """ 8191 8192 all_params = ['account_id', 'item_type', 'preserve_existing_shared_access', 'user_ids', 'account_shared_access'] 8193 all_params.append('callback') 8194 all_params.append('_return_http_data_only') 8195 all_params.append('_preload_content') 8196 all_params.append('_request_timeout') 8197 8198 params = locals() 8199 for key, val in iteritems(params['kwargs']): 8200 if key not in all_params: 8201 raise TypeError( 8202 "Got an unexpected keyword argument '%s'" 8203 " to method update_shared_access" % key 8204 ) 8205 params[key] = val 8206 del params['kwargs'] 8207 # verify the required parameter 'account_id' is set 8208 if ('account_id' not in params) or (params['account_id'] is None): 8209 raise ValueError("Missing the required parameter `account_id` when calling `update_shared_access`") 8210 8211 8212 collection_formats = {} 8213 8214 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 8215 path_params = {} 8216 if 'account_id' in params: 8217 path_params['accountId'] = params['account_id'] 8218 8219 query_params = {} 8220 if 'item_type' in params: 8221 query_params['item_type'] = params['item_type'] 8222 if 'preserve_existing_shared_access' in params: 8223 query_params['preserve_existing_shared_access'] = params['preserve_existing_shared_access'] 8224 if 'user_ids' in params: 8225 query_params['user_ids'] = params['user_ids'] 8226 8227 header_params = {} 8228 8229 form_params = [] 8230 local_var_files = {} 8231 8232 body_params = None 8233 if 'account_shared_access' in params: 8234 body_params = params['account_shared_access'] 8235 # HTTP header `Accept` 8236 header_params['Accept'] = self.api_client.\ 8237 select_header_accept(['application/json']) 8238 8239 # Authentication setting 8240 auth_settings = [] 8241 8242 return self.api_client.call_api(resource_path, 'PUT', 8243 path_params, 8244 query_params, 8245 header_params, 8246 body=body_params, 8247 post_params=form_params, 8248 files=local_var_files, 8249 response_type='AccountSharedAccess', 8250 auth_settings=auth_settings, 8251 callback=params.get('callback'), 8252 _return_http_data_only=params.get('_return_http_data_only'), 8253 _preload_content=params.get('_preload_content', True), 8254 _request_timeout=params.get('_request_timeout'), 8255 collection_formats=collection_formats) 8256 8257 def update_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 8258 """ 8259 Updates the user authorization 8260 This method makes a synchronous HTTP request by default. To make an 8261 asynchronous HTTP request, please define a `callback` function 8262 to be invoked when receiving the response. 8263 >>> def callback_function(response): 8264 >>> pprint(response) 8265 >>> 8266 >>> thread = api.update_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 8267 8268 :param callback function: The callback function 8269 for asynchronous request. (optional) 8270 :param str account_id: The external account number (int) or account ID Guid. (required) 8271 :param str authorization_id: (required) 8272 :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) 8273 :param UserAuthorizationUpdateRequest user_authorization_update_request: 8274 :return: UserAuthorization 8275 If the method is called asynchronously, 8276 returns the request thread. 8277 """ 8278 kwargs['_return_http_data_only'] = True 8279 if kwargs.get('callback'): 8280 return self.update_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 8281 else: 8282 (data) = self.update_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 8283 return data 8284 8285 def update_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 8286 """ 8287 Updates the user authorization 8288 This method makes a synchronous HTTP request by default. To make an 8289 asynchronous HTTP request, please define a `callback` function 8290 to be invoked when receiving the response. 8291 >>> def callback_function(response): 8292 >>> pprint(response) 8293 >>> 8294 >>> thread = api.update_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 8295 8296 :param callback function: The callback function 8297 for asynchronous request. (optional) 8298 :param str account_id: The external account number (int) or account ID Guid. (required) 8299 :param str authorization_id: (required) 8300 :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) 8301 :param UserAuthorizationUpdateRequest user_authorization_update_request: 8302 :return: UserAuthorization 8303 If the method is called asynchronously, 8304 returns the request thread. 8305 """ 8306 8307 all_params = ['account_id', 'authorization_id', 'user_id', 'user_authorization_update_request'] 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_user_authorization" % 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_user_authorization`") 8325 # verify the required parameter 'authorization_id' is set 8326 if ('authorization_id' not in params) or (params['authorization_id'] is None): 8327 raise ValueError("Missing the required parameter `authorization_id` when calling `update_user_authorization`") 8328 # verify the required parameter 'user_id' is set 8329 if ('user_id' not in params) or (params['user_id'] is None): 8330 raise ValueError("Missing the required parameter `user_id` when calling `update_user_authorization`") 8331 8332 8333 collection_formats = {} 8334 8335 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 8336 path_params = {} 8337 if 'account_id' in params: 8338 path_params['accountId'] = params['account_id'] 8339 if 'authorization_id' in params: 8340 path_params['authorizationId'] = params['authorization_id'] 8341 if 'user_id' in params: 8342 path_params['userId'] = params['user_id'] 8343 8344 query_params = {} 8345 8346 header_params = {} 8347 8348 form_params = [] 8349 local_var_files = {} 8350 8351 body_params = None 8352 if 'user_authorization_update_request' in params: 8353 body_params = params['user_authorization_update_request'] 8354 # HTTP header `Accept` 8355 header_params['Accept'] = self.api_client.\ 8356 select_header_accept(['application/json']) 8357 8358 # Authentication setting 8359 auth_settings = [] 8360 8361 return self.api_client.call_api(resource_path, 'PUT', 8362 path_params, 8363 query_params, 8364 header_params, 8365 body=body_params, 8366 post_params=form_params, 8367 files=local_var_files, 8368 response_type='UserAuthorization', 8369 auth_settings=auth_settings, 8370 callback=params.get('callback'), 8371 _return_http_data_only=params.get('_return_http_data_only'), 8372 _preload_content=params.get('_preload_content', True), 8373 _request_timeout=params.get('_request_timeout'), 8374 collection_formats=collection_formats) 8375 8376 def update_watermark(self, account_id, **kwargs): 8377 """ 8378 Update watermark information. 8379 8380 This method makes a synchronous HTTP request by default. To make an 8381 asynchronous HTTP request, please define a `callback` function 8382 to be invoked when receiving the response. 8383 >>> def callback_function(response): 8384 >>> pprint(response) 8385 >>> 8386 >>> thread = api.update_watermark(account_id, callback=callback_function) 8387 8388 :param callback function: The callback function 8389 for asynchronous request. (optional) 8390 :param str account_id: The external account number (int) or account ID Guid. (required) 8391 :param Watermark watermark: 8392 :return: Watermark 8393 If the method is called asynchronously, 8394 returns the request thread. 8395 """ 8396 kwargs['_return_http_data_only'] = True 8397 if kwargs.get('callback'): 8398 return self.update_watermark_with_http_info(account_id, **kwargs) 8399 else: 8400 (data) = self.update_watermark_with_http_info(account_id, **kwargs) 8401 return data 8402 8403 def update_watermark_with_http_info(self, account_id, **kwargs): 8404 """ 8405 Update watermark information. 8406 8407 This method makes a synchronous HTTP request by default. To make an 8408 asynchronous HTTP request, please define a `callback` function 8409 to be invoked when receiving the response. 8410 >>> def callback_function(response): 8411 >>> pprint(response) 8412 >>> 8413 >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function) 8414 8415 :param callback function: The callback function 8416 for asynchronous request. (optional) 8417 :param str account_id: The external account number (int) or account ID Guid. (required) 8418 :param Watermark watermark: 8419 :return: Watermark 8420 If the method is called asynchronously, 8421 returns the request thread. 8422 """ 8423 8424 all_params = ['account_id', 'watermark'] 8425 all_params.append('callback') 8426 all_params.append('_return_http_data_only') 8427 all_params.append('_preload_content') 8428 all_params.append('_request_timeout') 8429 8430 params = locals() 8431 for key, val in iteritems(params['kwargs']): 8432 if key not in all_params: 8433 raise TypeError( 8434 "Got an unexpected keyword argument '%s'" 8435 " to method update_watermark" % key 8436 ) 8437 params[key] = val 8438 del params['kwargs'] 8439 # verify the required parameter 'account_id' is set 8440 if ('account_id' not in params) or (params['account_id'] is None): 8441 raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`") 8442 8443 8444 collection_formats = {} 8445 8446 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 8447 path_params = {} 8448 if 'account_id' in params: 8449 path_params['accountId'] = params['account_id'] 8450 8451 query_params = {} 8452 8453 header_params = {} 8454 8455 form_params = [] 8456 local_var_files = {} 8457 8458 body_params = None 8459 if 'watermark' in params: 8460 body_params = params['watermark'] 8461 # HTTP header `Accept` 8462 header_params['Accept'] = self.api_client.\ 8463 select_header_accept(['application/json']) 8464 8465 # Authentication setting 8466 auth_settings = [] 8467 8468 return self.api_client.call_api(resource_path, 'PUT', 8469 path_params, 8470 query_params, 8471 header_params, 8472 body=body_params, 8473 post_params=form_params, 8474 files=local_var_files, 8475 response_type='Watermark', 8476 auth_settings=auth_settings, 8477 callback=params.get('callback'), 8478 _return_http_data_only=params.get('_return_http_data_only'), 8479 _preload_content=params.get('_preload_content', True), 8480 _request_timeout=params.get('_request_timeout'), 8481 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 :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 :return: None 854 If the method is called asynchronously, 855 returns the request thread. 856 """ 857 858 all_params = ['account_id'] 859 all_params.append('callback') 860 all_params.append('_return_http_data_only') 861 all_params.append('_preload_content') 862 all_params.append('_request_timeout') 863 864 params = locals() 865 for key, val in iteritems(params['kwargs']): 866 if key not in all_params: 867 raise TypeError( 868 "Got an unexpected keyword argument '%s'" 869 " to method delete" % key 870 ) 871 params[key] = val 872 del params['kwargs'] 873 # verify the required parameter 'account_id' is set 874 if ('account_id' not in params) or (params['account_id'] is None): 875 raise ValueError("Missing the required parameter `account_id` when calling `delete`") 876 877 878 collection_formats = {} 879 880 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 881 path_params = {} 882 if 'account_id' in params: 883 path_params['accountId'] = params['account_id'] 884 885 query_params = {} 886 887 header_params = {} 888 889 form_params = [] 890 local_var_files = {} 891 892 body_params = None 893 # HTTP header `Accept` 894 header_params['Accept'] = self.api_client.\ 895 select_header_accept(['application/json']) 896 897 # Authentication setting 898 auth_settings = [] 899 900 return self.api_client.call_api(resource_path, 'DELETE', 901 path_params, 902 query_params, 903 header_params, 904 body=body_params, 905 post_params=form_params, 906 files=local_var_files, 907 response_type=None, 908 auth_settings=auth_settings, 909 callback=params.get('callback'), 910 _return_http_data_only=params.get('_return_http_data_only'), 911 _preload_content=params.get('_preload_content', True), 912 _request_timeout=params.get('_request_timeout'), 913 collection_formats=collection_formats) 914 915 def delete_account_signature(self, account_id, signature_id, **kwargs): 916 """ 917 Close the specified signature by Id. 918 919 This method makes a synchronous HTTP request by default. To make an 920 asynchronous HTTP request, please define a `callback` function 921 to be invoked when receiving the response. 922 >>> def callback_function(response): 923 >>> pprint(response) 924 >>> 925 >>> thread = api.delete_account_signature(account_id, signature_id, callback=callback_function) 926 927 :param callback function: The callback function 928 for asynchronous request. (optional) 929 :param str account_id: The external account number (int) or account ID Guid. (required) 930 :param str signature_id: The ID of the signature being accessed. (required) 931 :return: None 932 If the method is called asynchronously, 933 returns the request thread. 934 """ 935 kwargs['_return_http_data_only'] = True 936 if kwargs.get('callback'): 937 return self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 938 else: 939 (data) = self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 940 return data 941 942 def delete_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 943 """ 944 Close the specified signature by Id. 945 946 This method makes a synchronous HTTP request by default. To make an 947 asynchronous HTTP request, please define a `callback` function 948 to be invoked when receiving the response. 949 >>> def callback_function(response): 950 >>> pprint(response) 951 >>> 952 >>> thread = api.delete_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 953 954 :param callback function: The callback function 955 for asynchronous request. (optional) 956 :param str account_id: The external account number (int) or account ID Guid. (required) 957 :param str signature_id: The ID of the signature being accessed. (required) 958 :return: None 959 If the method is called asynchronously, 960 returns the request thread. 961 """ 962 963 all_params = ['account_id', 'signature_id'] 964 all_params.append('callback') 965 all_params.append('_return_http_data_only') 966 all_params.append('_preload_content') 967 all_params.append('_request_timeout') 968 969 params = locals() 970 for key, val in iteritems(params['kwargs']): 971 if key not in all_params: 972 raise TypeError( 973 "Got an unexpected keyword argument '%s'" 974 " to method delete_account_signature" % key 975 ) 976 params[key] = val 977 del params['kwargs'] 978 # verify the required parameter 'account_id' is set 979 if ('account_id' not in params) or (params['account_id'] is None): 980 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature`") 981 # verify the required parameter 'signature_id' is set 982 if ('signature_id' not in params) or (params['signature_id'] is None): 983 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature`") 984 985 986 collection_formats = {} 987 988 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 989 path_params = {} 990 if 'account_id' in params: 991 path_params['accountId'] = params['account_id'] 992 if 'signature_id' in params: 993 path_params['signatureId'] = params['signature_id'] 994 995 query_params = {} 996 997 header_params = {} 998 999 form_params = [] 1000 local_var_files = {} 1001 1002 body_params = None 1003 # HTTP header `Accept` 1004 header_params['Accept'] = self.api_client.\ 1005 select_header_accept(['application/json']) 1006 1007 # Authentication setting 1008 auth_settings = [] 1009 1010 return self.api_client.call_api(resource_path, 'DELETE', 1011 path_params, 1012 query_params, 1013 header_params, 1014 body=body_params, 1015 post_params=form_params, 1016 files=local_var_files, 1017 response_type=None, 1018 auth_settings=auth_settings, 1019 callback=params.get('callback'), 1020 _return_http_data_only=params.get('_return_http_data_only'), 1021 _preload_content=params.get('_preload_content', True), 1022 _request_timeout=params.get('_request_timeout'), 1023 collection_formats=collection_formats) 1024 1025 def delete_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 1026 """ 1027 Deletes a signature, initials, or stamps image. 1028 1029 This method makes a synchronous HTTP request by default. To make an 1030 asynchronous HTTP request, please define a `callback` function 1031 to be invoked when receiving the response. 1032 >>> def callback_function(response): 1033 >>> pprint(response) 1034 >>> 1035 >>> thread = api.delete_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 1036 1037 :param callback function: The callback function 1038 for asynchronous request. (optional) 1039 :param str account_id: The external account number (int) or account ID Guid. (required) 1040 :param str image_type: One of **signature_image** or **initials_image**. (required) 1041 :param str signature_id: The ID of the signature being accessed. (required) 1042 :return: AccountSignature 1043 If the method is called asynchronously, 1044 returns the request thread. 1045 """ 1046 kwargs['_return_http_data_only'] = True 1047 if kwargs.get('callback'): 1048 return self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 1049 else: 1050 (data) = self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 1051 return data 1052 1053 def delete_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 1054 """ 1055 Deletes a signature, initials, or stamps image. 1056 1057 This method makes a synchronous HTTP request by default. To make an 1058 asynchronous HTTP request, please define a `callback` function 1059 to be invoked when receiving the response. 1060 >>> def callback_function(response): 1061 >>> pprint(response) 1062 >>> 1063 >>> thread = api.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 1064 1065 :param callback function: The callback function 1066 for asynchronous request. (optional) 1067 :param str account_id: The external account number (int) or account ID Guid. (required) 1068 :param str image_type: One of **signature_image** or **initials_image**. (required) 1069 :param str signature_id: The ID of the signature being accessed. (required) 1070 :return: AccountSignature 1071 If the method is called asynchronously, 1072 returns the request thread. 1073 """ 1074 1075 all_params = ['account_id', 'image_type', 'signature_id'] 1076 all_params.append('callback') 1077 all_params.append('_return_http_data_only') 1078 all_params.append('_preload_content') 1079 all_params.append('_request_timeout') 1080 1081 params = locals() 1082 for key, val in iteritems(params['kwargs']): 1083 if key not in all_params: 1084 raise TypeError( 1085 "Got an unexpected keyword argument '%s'" 1086 " to method delete_account_signature_image" % key 1087 ) 1088 params[key] = val 1089 del params['kwargs'] 1090 # verify the required parameter 'account_id' is set 1091 if ('account_id' not in params) or (params['account_id'] is None): 1092 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature_image`") 1093 # verify the required parameter 'image_type' is set 1094 if ('image_type' not in params) or (params['image_type'] is None): 1095 raise ValueError("Missing the required parameter `image_type` when calling `delete_account_signature_image`") 1096 # verify the required parameter 'signature_id' is set 1097 if ('signature_id' not in params) or (params['signature_id'] is None): 1098 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature_image`") 1099 1100 1101 collection_formats = {} 1102 1103 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 1104 path_params = {} 1105 if 'account_id' in params: 1106 path_params['accountId'] = params['account_id'] 1107 if 'image_type' in params: 1108 path_params['imageType'] = params['image_type'] 1109 if 'signature_id' in params: 1110 path_params['signatureId'] = params['signature_id'] 1111 1112 query_params = {} 1113 1114 header_params = {} 1115 1116 form_params = [] 1117 local_var_files = {} 1118 1119 body_params = None 1120 # HTTP header `Accept` 1121 header_params['Accept'] = self.api_client.\ 1122 select_header_accept(['application/json']) 1123 1124 # Authentication setting 1125 auth_settings = [] 1126 1127 return self.api_client.call_api(resource_path, 'DELETE', 1128 path_params, 1129 query_params, 1130 header_params, 1131 body=body_params, 1132 post_params=form_params, 1133 files=local_var_files, 1134 response_type='AccountSignature', 1135 auth_settings=auth_settings, 1136 callback=params.get('callback'), 1137 _return_http_data_only=params.get('_return_http_data_only'), 1138 _preload_content=params.get('_preload_content', True), 1139 _request_timeout=params.get('_request_timeout'), 1140 collection_formats=collection_formats) 1141 1142 def delete_brand(self, account_id, brand_id, **kwargs): 1143 """ 1144 Removes a brand. 1145 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**). 1146 This method makes a synchronous HTTP request by default. To make an 1147 asynchronous HTTP request, please define a `callback` function 1148 to be invoked when receiving the response. 1149 >>> def callback_function(response): 1150 >>> pprint(response) 1151 >>> 1152 >>> thread = api.delete_brand(account_id, brand_id, callback=callback_function) 1153 1154 :param callback function: The callback function 1155 for asynchronous request. (optional) 1156 :param str account_id: The external account number (int) or account ID Guid. (required) 1157 :param str brand_id: The unique identifier of a brand. (required) 1158 :return: None 1159 If the method is called asynchronously, 1160 returns the request thread. 1161 """ 1162 kwargs['_return_http_data_only'] = True 1163 if kwargs.get('callback'): 1164 return self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 1165 else: 1166 (data) = self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 1167 return data 1168 1169 def delete_brand_with_http_info(self, account_id, brand_id, **kwargs): 1170 """ 1171 Removes a brand. 1172 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**). 1173 This method makes a synchronous HTTP request by default. To make an 1174 asynchronous HTTP request, please define a `callback` function 1175 to be invoked when receiving the response. 1176 >>> def callback_function(response): 1177 >>> pprint(response) 1178 >>> 1179 >>> thread = api.delete_brand_with_http_info(account_id, brand_id, callback=callback_function) 1180 1181 :param callback function: The callback function 1182 for asynchronous request. (optional) 1183 :param str account_id: The external account number (int) or account ID Guid. (required) 1184 :param str brand_id: The unique identifier of a brand. (required) 1185 :return: None 1186 If the method is called asynchronously, 1187 returns the request thread. 1188 """ 1189 1190 all_params = ['account_id', 'brand_id'] 1191 all_params.append('callback') 1192 all_params.append('_return_http_data_only') 1193 all_params.append('_preload_content') 1194 all_params.append('_request_timeout') 1195 1196 params = locals() 1197 for key, val in iteritems(params['kwargs']): 1198 if key not in all_params: 1199 raise TypeError( 1200 "Got an unexpected keyword argument '%s'" 1201 " to method delete_brand" % key 1202 ) 1203 params[key] = val 1204 del params['kwargs'] 1205 # verify the required parameter 'account_id' is set 1206 if ('account_id' not in params) or (params['account_id'] is None): 1207 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand`") 1208 # verify the required parameter 'brand_id' is set 1209 if ('brand_id' not in params) or (params['brand_id'] is None): 1210 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand`") 1211 1212 1213 collection_formats = {} 1214 1215 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 1216 path_params = {} 1217 if 'account_id' in params: 1218 path_params['accountId'] = params['account_id'] 1219 if 'brand_id' in params: 1220 path_params['brandId'] = params['brand_id'] 1221 1222 query_params = {} 1223 1224 header_params = {} 1225 1226 form_params = [] 1227 local_var_files = {} 1228 1229 body_params = None 1230 # HTTP header `Accept` 1231 header_params['Accept'] = self.api_client.\ 1232 select_header_accept(['application/json']) 1233 1234 # Authentication setting 1235 auth_settings = [] 1236 1237 return self.api_client.call_api(resource_path, 'DELETE', 1238 path_params, 1239 query_params, 1240 header_params, 1241 body=body_params, 1242 post_params=form_params, 1243 files=local_var_files, 1244 response_type=None, 1245 auth_settings=auth_settings, 1246 callback=params.get('callback'), 1247 _return_http_data_only=params.get('_return_http_data_only'), 1248 _preload_content=params.get('_preload_content', True), 1249 _request_timeout=params.get('_request_timeout'), 1250 collection_formats=collection_formats) 1251 1252 def delete_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 1253 """ 1254 Delete one branding logo. 1255 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**). 1256 This method makes a synchronous HTTP request by default. To make an 1257 asynchronous HTTP request, please define a `callback` function 1258 to be invoked when receiving the response. 1259 >>> def callback_function(response): 1260 >>> pprint(response) 1261 >>> 1262 >>> thread = api.delete_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 1263 1264 :param callback function: The callback function 1265 for asynchronous request. (optional) 1266 :param str account_id: The external account number (int) or account ID Guid. (required) 1267 :param str brand_id: The unique identifier of a brand. (required) 1268 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1269 :return: None 1270 If the method is called asynchronously, 1271 returns the request thread. 1272 """ 1273 kwargs['_return_http_data_only'] = True 1274 if kwargs.get('callback'): 1275 return self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1276 else: 1277 (data) = self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1278 return data 1279 1280 def delete_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 1281 """ 1282 Delete one branding logo. 1283 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**). 1284 This method makes a synchronous HTTP request by default. To make an 1285 asynchronous HTTP request, please define a `callback` function 1286 to be invoked when receiving the response. 1287 >>> def callback_function(response): 1288 >>> pprint(response) 1289 >>> 1290 >>> thread = api.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 1291 1292 :param callback function: The callback function 1293 for asynchronous request. (optional) 1294 :param str account_id: The external account number (int) or account ID Guid. (required) 1295 :param str brand_id: The unique identifier of a brand. (required) 1296 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1297 :return: None 1298 If the method is called asynchronously, 1299 returns the request thread. 1300 """ 1301 1302 all_params = ['account_id', 'brand_id', 'logo_type'] 1303 all_params.append('callback') 1304 all_params.append('_return_http_data_only') 1305 all_params.append('_preload_content') 1306 all_params.append('_request_timeout') 1307 1308 params = locals() 1309 for key, val in iteritems(params['kwargs']): 1310 if key not in all_params: 1311 raise TypeError( 1312 "Got an unexpected keyword argument '%s'" 1313 " to method delete_brand_logo_by_type" % key 1314 ) 1315 params[key] = val 1316 del params['kwargs'] 1317 # verify the required parameter 'account_id' is set 1318 if ('account_id' not in params) or (params['account_id'] is None): 1319 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand_logo_by_type`") 1320 # verify the required parameter 'brand_id' is set 1321 if ('brand_id' not in params) or (params['brand_id'] is None): 1322 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand_logo_by_type`") 1323 # verify the required parameter 'logo_type' is set 1324 if ('logo_type' not in params) or (params['logo_type'] is None): 1325 raise ValueError("Missing the required parameter `logo_type` when calling `delete_brand_logo_by_type`") 1326 1327 1328 collection_formats = {} 1329 1330 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 1331 path_params = {} 1332 if 'account_id' in params: 1333 path_params['accountId'] = params['account_id'] 1334 if 'brand_id' in params: 1335 path_params['brandId'] = params['brand_id'] 1336 if 'logo_type' in params: 1337 path_params['logoType'] = params['logo_type'] 1338 1339 query_params = {} 1340 1341 header_params = {} 1342 1343 form_params = [] 1344 local_var_files = {} 1345 1346 body_params = None 1347 # HTTP header `Accept` 1348 header_params['Accept'] = self.api_client.\ 1349 select_header_accept(['application/json']) 1350 1351 # Authentication setting 1352 auth_settings = [] 1353 1354 return self.api_client.call_api(resource_path, 'DELETE', 1355 path_params, 1356 query_params, 1357 header_params, 1358 body=body_params, 1359 post_params=form_params, 1360 files=local_var_files, 1361 response_type=None, 1362 auth_settings=auth_settings, 1363 callback=params.get('callback'), 1364 _return_http_data_only=params.get('_return_http_data_only'), 1365 _preload_content=params.get('_preload_content', True), 1366 _request_timeout=params.get('_request_timeout'), 1367 collection_formats=collection_formats) 1368 1369 def delete_brands(self, account_id, **kwargs): 1370 """ 1371 Deletes one or more brand profiles. 1372 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. 1373 This method makes a synchronous HTTP request by default. To make an 1374 asynchronous HTTP request, please define a `callback` function 1375 to be invoked when receiving the response. 1376 >>> def callback_function(response): 1377 >>> pprint(response) 1378 >>> 1379 >>> thread = api.delete_brands(account_id, callback=callback_function) 1380 1381 :param callback function: The callback function 1382 for asynchronous request. (optional) 1383 :param str account_id: The external account number (int) or account ID Guid. (required) 1384 :param BrandsRequest brands_request: 1385 :return: BrandsResponse 1386 If the method is called asynchronously, 1387 returns the request thread. 1388 """ 1389 kwargs['_return_http_data_only'] = True 1390 if kwargs.get('callback'): 1391 return self.delete_brands_with_http_info(account_id, **kwargs) 1392 else: 1393 (data) = self.delete_brands_with_http_info(account_id, **kwargs) 1394 return data 1395 1396 def delete_brands_with_http_info(self, account_id, **kwargs): 1397 """ 1398 Deletes one or more brand profiles. 1399 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. 1400 This method makes a synchronous HTTP request by default. To make an 1401 asynchronous HTTP request, please define a `callback` function 1402 to be invoked when receiving the response. 1403 >>> def callback_function(response): 1404 >>> pprint(response) 1405 >>> 1406 >>> thread = api.delete_brands_with_http_info(account_id, callback=callback_function) 1407 1408 :param callback function: The callback function 1409 for asynchronous request. (optional) 1410 :param str account_id: The external account number (int) or account ID Guid. (required) 1411 :param BrandsRequest brands_request: 1412 :return: BrandsResponse 1413 If the method is called asynchronously, 1414 returns the request thread. 1415 """ 1416 1417 all_params = ['account_id', 'brands_request'] 1418 all_params.append('callback') 1419 all_params.append('_return_http_data_only') 1420 all_params.append('_preload_content') 1421 all_params.append('_request_timeout') 1422 1423 params = locals() 1424 for key, val in iteritems(params['kwargs']): 1425 if key not in all_params: 1426 raise TypeError( 1427 "Got an unexpected keyword argument '%s'" 1428 " to method delete_brands" % key 1429 ) 1430 params[key] = val 1431 del params['kwargs'] 1432 # verify the required parameter 'account_id' is set 1433 if ('account_id' not in params) or (params['account_id'] is None): 1434 raise ValueError("Missing the required parameter `account_id` when calling `delete_brands`") 1435 1436 1437 collection_formats = {} 1438 1439 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 1440 path_params = {} 1441 if 'account_id' in params: 1442 path_params['accountId'] = params['account_id'] 1443 1444 query_params = {} 1445 1446 header_params = {} 1447 1448 form_params = [] 1449 local_var_files = {} 1450 1451 body_params = None 1452 if 'brands_request' in params: 1453 body_params = params['brands_request'] 1454 # HTTP header `Accept` 1455 header_params['Accept'] = self.api_client.\ 1456 select_header_accept(['application/json']) 1457 1458 # Authentication setting 1459 auth_settings = [] 1460 1461 return self.api_client.call_api(resource_path, 'DELETE', 1462 path_params, 1463 query_params, 1464 header_params, 1465 body=body_params, 1466 post_params=form_params, 1467 files=local_var_files, 1468 response_type='BrandsResponse', 1469 auth_settings=auth_settings, 1470 callback=params.get('callback'), 1471 _return_http_data_only=params.get('_return_http_data_only'), 1472 _preload_content=params.get('_preload_content', True), 1473 _request_timeout=params.get('_request_timeout'), 1474 collection_formats=collection_formats) 1475 1476 def delete_captive_recipient(self, account_id, recipient_part, **kwargs): 1477 """ 1478 Deletes the signature for one or more captive recipient records. 1479 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. 1480 This method makes a synchronous HTTP request by default. To make an 1481 asynchronous HTTP request, please define a `callback` function 1482 to be invoked when receiving the response. 1483 >>> def callback_function(response): 1484 >>> pprint(response) 1485 >>> 1486 >>> thread = api.delete_captive_recipient(account_id, recipient_part, callback=callback_function) 1487 1488 :param callback function: The callback function 1489 for asynchronous request. (optional) 1490 :param str account_id: The external account number (int) or account ID Guid. (required) 1491 :param str recipient_part: (required) 1492 :param CaptiveRecipientInformation captive_recipient_information: 1493 :return: CaptiveRecipientInformation 1494 If the method is called asynchronously, 1495 returns the request thread. 1496 """ 1497 kwargs['_return_http_data_only'] = True 1498 if kwargs.get('callback'): 1499 return self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1500 else: 1501 (data) = self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1502 return data 1503 1504 def delete_captive_recipient_with_http_info(self, account_id, recipient_part, **kwargs): 1505 """ 1506 Deletes the signature for one or more captive recipient records. 1507 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. 1508 This method makes a synchronous HTTP request by default. To make an 1509 asynchronous HTTP request, please define a `callback` function 1510 to be invoked when receiving the response. 1511 >>> def callback_function(response): 1512 >>> pprint(response) 1513 >>> 1514 >>> thread = api.delete_captive_recipient_with_http_info(account_id, recipient_part, callback=callback_function) 1515 1516 :param callback function: The callback function 1517 for asynchronous request. (optional) 1518 :param str account_id: The external account number (int) or account ID Guid. (required) 1519 :param str recipient_part: (required) 1520 :param CaptiveRecipientInformation captive_recipient_information: 1521 :return: CaptiveRecipientInformation 1522 If the method is called asynchronously, 1523 returns the request thread. 1524 """ 1525 1526 all_params = ['account_id', 'recipient_part', 'captive_recipient_information'] 1527 all_params.append('callback') 1528 all_params.append('_return_http_data_only') 1529 all_params.append('_preload_content') 1530 all_params.append('_request_timeout') 1531 1532 params = locals() 1533 for key, val in iteritems(params['kwargs']): 1534 if key not in all_params: 1535 raise TypeError( 1536 "Got an unexpected keyword argument '%s'" 1537 " to method delete_captive_recipient" % key 1538 ) 1539 params[key] = val 1540 del params['kwargs'] 1541 # verify the required parameter 'account_id' is set 1542 if ('account_id' not in params) or (params['account_id'] is None): 1543 raise ValueError("Missing the required parameter `account_id` when calling `delete_captive_recipient`") 1544 # verify the required parameter 'recipient_part' is set 1545 if ('recipient_part' not in params) or (params['recipient_part'] is None): 1546 raise ValueError("Missing the required parameter `recipient_part` when calling `delete_captive_recipient`") 1547 1548 1549 collection_formats = {} 1550 1551 resource_path = '/v2.1/accounts/{accountId}/captive_recipients/{recipientPart}'.replace('{format}', 'json') 1552 path_params = {} 1553 if 'account_id' in params: 1554 path_params['accountId'] = params['account_id'] 1555 if 'recipient_part' in params: 1556 path_params['recipientPart'] = params['recipient_part'] 1557 1558 query_params = {} 1559 1560 header_params = {} 1561 1562 form_params = [] 1563 local_var_files = {} 1564 1565 body_params = None 1566 if 'captive_recipient_information' in params: 1567 body_params = params['captive_recipient_information'] 1568 # HTTP header `Accept` 1569 header_params['Accept'] = self.api_client.\ 1570 select_header_accept(['application/json']) 1571 1572 # Authentication setting 1573 auth_settings = [] 1574 1575 return self.api_client.call_api(resource_path, 'DELETE', 1576 path_params, 1577 query_params, 1578 header_params, 1579 body=body_params, 1580 post_params=form_params, 1581 files=local_var_files, 1582 response_type='CaptiveRecipientInformation', 1583 auth_settings=auth_settings, 1584 callback=params.get('callback'), 1585 _return_http_data_only=params.get('_return_http_data_only'), 1586 _preload_content=params.get('_preload_content', True), 1587 _request_timeout=params.get('_request_timeout'), 1588 collection_formats=collection_formats) 1589 1590 def delete_custom_field(self, account_id, custom_field_id, **kwargs): 1591 """ 1592 Delete an existing account custom field. 1593 This method deletes an existing account custom field. 1594 This method makes a synchronous HTTP request by default. To make an 1595 asynchronous HTTP request, please define a `callback` function 1596 to be invoked when receiving the response. 1597 >>> def callback_function(response): 1598 >>> pprint(response) 1599 >>> 1600 >>> thread = api.delete_custom_field(account_id, custom_field_id, callback=callback_function) 1601 1602 :param callback function: The callback function 1603 for asynchronous request. (optional) 1604 :param str account_id: The external account number (int) or account ID Guid. (required) 1605 :param str custom_field_id: (required) 1606 :param str apply_to_templates: 1607 :return: None 1608 If the method is called asynchronously, 1609 returns the request thread. 1610 """ 1611 kwargs['_return_http_data_only'] = True 1612 if kwargs.get('callback'): 1613 return self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1614 else: 1615 (data) = self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1616 return data 1617 1618 def delete_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 1619 """ 1620 Delete an existing account custom field. 1621 This method deletes an existing account custom field. 1622 This method makes a synchronous HTTP request by default. To make an 1623 asynchronous HTTP request, please define a `callback` function 1624 to be invoked when receiving the response. 1625 >>> def callback_function(response): 1626 >>> pprint(response) 1627 >>> 1628 >>> thread = api.delete_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 1629 1630 :param callback function: The callback function 1631 for asynchronous request. (optional) 1632 :param str account_id: The external account number (int) or account ID Guid. (required) 1633 :param str custom_field_id: (required) 1634 :param str apply_to_templates: 1635 :return: None 1636 If the method is called asynchronously, 1637 returns the request thread. 1638 """ 1639 1640 all_params = ['account_id', 'custom_field_id', 'apply_to_templates'] 1641 all_params.append('callback') 1642 all_params.append('_return_http_data_only') 1643 all_params.append('_preload_content') 1644 all_params.append('_request_timeout') 1645 1646 params = locals() 1647 for key, val in iteritems(params['kwargs']): 1648 if key not in all_params: 1649 raise TypeError( 1650 "Got an unexpected keyword argument '%s'" 1651 " to method delete_custom_field" % key 1652 ) 1653 params[key] = val 1654 del params['kwargs'] 1655 # verify the required parameter 'account_id' is set 1656 if ('account_id' not in params) or (params['account_id'] is None): 1657 raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_field`") 1658 # verify the required parameter 'custom_field_id' is set 1659 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 1660 raise ValueError("Missing the required parameter `custom_field_id` when calling `delete_custom_field`") 1661 1662 1663 collection_formats = {} 1664 1665 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 1666 path_params = {} 1667 if 'account_id' in params: 1668 path_params['accountId'] = params['account_id'] 1669 if 'custom_field_id' in params: 1670 path_params['customFieldId'] = params['custom_field_id'] 1671 1672 query_params = {} 1673 if 'apply_to_templates' in params: 1674 query_params['apply_to_templates'] = params['apply_to_templates'] 1675 1676 header_params = {} 1677 1678 form_params = [] 1679 local_var_files = {} 1680 1681 body_params = None 1682 # HTTP header `Accept` 1683 header_params['Accept'] = self.api_client.\ 1684 select_header_accept(['application/json']) 1685 1686 # Authentication setting 1687 auth_settings = [] 1688 1689 return self.api_client.call_api(resource_path, 'DELETE', 1690 path_params, 1691 query_params, 1692 header_params, 1693 body=body_params, 1694 post_params=form_params, 1695 files=local_var_files, 1696 response_type=None, 1697 auth_settings=auth_settings, 1698 callback=params.get('callback'), 1699 _return_http_data_only=params.get('_return_http_data_only'), 1700 _preload_content=params.get('_preload_content', True), 1701 _request_timeout=params.get('_request_timeout'), 1702 collection_formats=collection_formats) 1703 1704 def delete_e_note_configuration(self, account_id, **kwargs): 1705 """ 1706 Deletes configuration information for the eNote eOriginal integration. 1707 1708 This method makes a synchronous HTTP request by default. To make an 1709 asynchronous HTTP request, please define a `callback` function 1710 to be invoked when receiving the response. 1711 >>> def callback_function(response): 1712 >>> pprint(response) 1713 >>> 1714 >>> thread = api.delete_e_note_configuration(account_id, callback=callback_function) 1715 1716 :param callback function: The callback function 1717 for asynchronous request. (optional) 1718 :param str account_id: The external account number (int) or account ID Guid. (required) 1719 :return: None 1720 If the method is called asynchronously, 1721 returns the request thread. 1722 """ 1723 kwargs['_return_http_data_only'] = True 1724 if kwargs.get('callback'): 1725 return self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1726 else: 1727 (data) = self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1728 return data 1729 1730 def delete_e_note_configuration_with_http_info(self, account_id, **kwargs): 1731 """ 1732 Deletes configuration information for the eNote eOriginal integration. 1733 1734 This method makes a synchronous HTTP request by default. To make an 1735 asynchronous HTTP request, please define a `callback` function 1736 to be invoked when receiving the response. 1737 >>> def callback_function(response): 1738 >>> pprint(response) 1739 >>> 1740 >>> thread = api.delete_e_note_configuration_with_http_info(account_id, callback=callback_function) 1741 1742 :param callback function: The callback function 1743 for asynchronous request. (optional) 1744 :param str account_id: The external account number (int) or account ID Guid. (required) 1745 :return: None 1746 If the method is called asynchronously, 1747 returns the request thread. 1748 """ 1749 1750 all_params = ['account_id'] 1751 all_params.append('callback') 1752 all_params.append('_return_http_data_only') 1753 all_params.append('_preload_content') 1754 all_params.append('_request_timeout') 1755 1756 params = locals() 1757 for key, val in iteritems(params['kwargs']): 1758 if key not in all_params: 1759 raise TypeError( 1760 "Got an unexpected keyword argument '%s'" 1761 " to method delete_e_note_configuration" % key 1762 ) 1763 params[key] = val 1764 del params['kwargs'] 1765 # verify the required parameter 'account_id' is set 1766 if ('account_id' not in params) or (params['account_id'] is None): 1767 raise ValueError("Missing the required parameter `account_id` when calling `delete_e_note_configuration`") 1768 1769 1770 collection_formats = {} 1771 1772 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 1773 path_params = {} 1774 if 'account_id' in params: 1775 path_params['accountId'] = params['account_id'] 1776 1777 query_params = {} 1778 1779 header_params = {} 1780 1781 form_params = [] 1782 local_var_files = {} 1783 1784 body_params = None 1785 # HTTP header `Accept` 1786 header_params['Accept'] = self.api_client.\ 1787 select_header_accept(['application/json']) 1788 1789 # Authentication setting 1790 auth_settings = [] 1791 1792 return self.api_client.call_api(resource_path, 'DELETE', 1793 path_params, 1794 query_params, 1795 header_params, 1796 body=body_params, 1797 post_params=form_params, 1798 files=local_var_files, 1799 response_type=None, 1800 auth_settings=auth_settings, 1801 callback=params.get('callback'), 1802 _return_http_data_only=params.get('_return_http_data_only'), 1803 _preload_content=params.get('_preload_content', True), 1804 _request_timeout=params.get('_request_timeout'), 1805 collection_formats=collection_formats) 1806 1807 def delete_permission_profile(self, account_id, permission_profile_id, **kwargs): 1808 """ 1809 Deletes a permissions profile within the specified account. 1810 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/) 1811 This method makes a synchronous HTTP request by default. To make an 1812 asynchronous HTTP request, please define a `callback` function 1813 to be invoked when receiving the response. 1814 >>> def callback_function(response): 1815 >>> pprint(response) 1816 >>> 1817 >>> thread = api.delete_permission_profile(account_id, permission_profile_id, callback=callback_function) 1818 1819 :param callback function: The callback function 1820 for asynchronous request. (optional) 1821 :param str account_id: The external account number (int) or account ID Guid. (required) 1822 :param str permission_profile_id: (required) 1823 :param str move_users_to: 1824 :return: None 1825 If the method is called asynchronously, 1826 returns the request thread. 1827 """ 1828 kwargs['_return_http_data_only'] = True 1829 if kwargs.get('callback'): 1830 return self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1831 else: 1832 (data) = self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1833 return data 1834 1835 def delete_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 1836 """ 1837 Deletes a permissions profile within the specified account. 1838 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/) 1839 This method makes a synchronous HTTP request by default. To make an 1840 asynchronous HTTP request, please define a `callback` function 1841 to be invoked when receiving the response. 1842 >>> def callback_function(response): 1843 >>> pprint(response) 1844 >>> 1845 >>> thread = api.delete_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 1846 1847 :param callback function: The callback function 1848 for asynchronous request. (optional) 1849 :param str account_id: The external account number (int) or account ID Guid. (required) 1850 :param str permission_profile_id: (required) 1851 :param str move_users_to: 1852 :return: None 1853 If the method is called asynchronously, 1854 returns the request thread. 1855 """ 1856 1857 all_params = ['account_id', 'permission_profile_id', 'move_users_to'] 1858 all_params.append('callback') 1859 all_params.append('_return_http_data_only') 1860 all_params.append('_preload_content') 1861 all_params.append('_request_timeout') 1862 1863 params = locals() 1864 for key, val in iteritems(params['kwargs']): 1865 if key not in all_params: 1866 raise TypeError( 1867 "Got an unexpected keyword argument '%s'" 1868 " to method delete_permission_profile" % key 1869 ) 1870 params[key] = val 1871 del params['kwargs'] 1872 # verify the required parameter 'account_id' is set 1873 if ('account_id' not in params) or (params['account_id'] is None): 1874 raise ValueError("Missing the required parameter `account_id` when calling `delete_permission_profile`") 1875 # verify the required parameter 'permission_profile_id' is set 1876 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 1877 raise ValueError("Missing the required parameter `permission_profile_id` when calling `delete_permission_profile`") 1878 1879 1880 collection_formats = {} 1881 1882 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 1883 path_params = {} 1884 if 'account_id' in params: 1885 path_params['accountId'] = params['account_id'] 1886 if 'permission_profile_id' in params: 1887 path_params['permissionProfileId'] = params['permission_profile_id'] 1888 1889 query_params = {} 1890 if 'move_users_to' in params: 1891 query_params['move_users_to'] = params['move_users_to'] 1892 1893 header_params = {} 1894 1895 form_params = [] 1896 local_var_files = {} 1897 1898 body_params = None 1899 # HTTP header `Accept` 1900 header_params['Accept'] = self.api_client.\ 1901 select_header_accept(['application/json']) 1902 1903 # Authentication setting 1904 auth_settings = [] 1905 1906 return self.api_client.call_api(resource_path, 'DELETE', 1907 path_params, 1908 query_params, 1909 header_params, 1910 body=body_params, 1911 post_params=form_params, 1912 files=local_var_files, 1913 response_type=None, 1914 auth_settings=auth_settings, 1915 callback=params.get('callback'), 1916 _return_http_data_only=params.get('_return_http_data_only'), 1917 _preload_content=params.get('_preload_content', True), 1918 _request_timeout=params.get('_request_timeout'), 1919 collection_formats=collection_formats) 1920 1921 def delete_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 1922 """ 1923 Deletes the user authorization 1924 This method makes a synchronous HTTP request by default. To make an 1925 asynchronous HTTP request, please define a `callback` function 1926 to be invoked when receiving the response. 1927 >>> def callback_function(response): 1928 >>> pprint(response) 1929 >>> 1930 >>> thread = api.delete_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 1931 1932 :param callback function: The callback function 1933 for asynchronous request. (optional) 1934 :param str account_id: The external account number (int) or account ID Guid. (required) 1935 :param str authorization_id: (required) 1936 :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) 1937 :return: None 1938 If the method is called asynchronously, 1939 returns the request thread. 1940 """ 1941 kwargs['_return_http_data_only'] = True 1942 if kwargs.get('callback'): 1943 return self.delete_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 1944 else: 1945 (data) = self.delete_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 1946 return data 1947 1948 def delete_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 1949 """ 1950 Deletes the user authorization 1951 This method makes a synchronous HTTP request by default. To make an 1952 asynchronous HTTP request, please define a `callback` function 1953 to be invoked when receiving the response. 1954 >>> def callback_function(response): 1955 >>> pprint(response) 1956 >>> 1957 >>> thread = api.delete_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 1958 1959 :param callback function: The callback function 1960 for asynchronous request. (optional) 1961 :param str account_id: The external account number (int) or account ID Guid. (required) 1962 :param str authorization_id: (required) 1963 :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) 1964 :return: None 1965 If the method is called asynchronously, 1966 returns the request thread. 1967 """ 1968 1969 all_params = ['account_id', 'authorization_id', 'user_id'] 1970 all_params.append('callback') 1971 all_params.append('_return_http_data_only') 1972 all_params.append('_preload_content') 1973 all_params.append('_request_timeout') 1974 1975 params = locals() 1976 for key, val in iteritems(params['kwargs']): 1977 if key not in all_params: 1978 raise TypeError( 1979 "Got an unexpected keyword argument '%s'" 1980 " to method delete_user_authorization" % key 1981 ) 1982 params[key] = val 1983 del params['kwargs'] 1984 # verify the required parameter 'account_id' is set 1985 if ('account_id' not in params) or (params['account_id'] is None): 1986 raise ValueError("Missing the required parameter `account_id` when calling `delete_user_authorization`") 1987 # verify the required parameter 'authorization_id' is set 1988 if ('authorization_id' not in params) or (params['authorization_id'] is None): 1989 raise ValueError("Missing the required parameter `authorization_id` when calling `delete_user_authorization`") 1990 # verify the required parameter 'user_id' is set 1991 if ('user_id' not in params) or (params['user_id'] is None): 1992 raise ValueError("Missing the required parameter `user_id` when calling `delete_user_authorization`") 1993 1994 1995 collection_formats = {} 1996 1997 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 1998 path_params = {} 1999 if 'account_id' in params: 2000 path_params['accountId'] = params['account_id'] 2001 if 'authorization_id' in params: 2002 path_params['authorizationId'] = params['authorization_id'] 2003 if 'user_id' in params: 2004 path_params['userId'] = params['user_id'] 2005 2006 query_params = {} 2007 2008 header_params = {} 2009 2010 form_params = [] 2011 local_var_files = {} 2012 2013 body_params = None 2014 # HTTP header `Accept` 2015 header_params['Accept'] = self.api_client.\ 2016 select_header_accept(['application/json']) 2017 2018 # Authentication setting 2019 auth_settings = [] 2020 2021 return self.api_client.call_api(resource_path, 'DELETE', 2022 path_params, 2023 query_params, 2024 header_params, 2025 body=body_params, 2026 post_params=form_params, 2027 files=local_var_files, 2028 response_type=None, 2029 auth_settings=auth_settings, 2030 callback=params.get('callback'), 2031 _return_http_data_only=params.get('_return_http_data_only'), 2032 _preload_content=params.get('_preload_content', True), 2033 _request_timeout=params.get('_request_timeout'), 2034 collection_formats=collection_formats) 2035 2036 def delete_user_authorizations(self, account_id, user_id, **kwargs): 2037 """ 2038 Creates ot updates user authorizations 2039 This method makes a synchronous HTTP request by default. To make an 2040 asynchronous HTTP request, please define a `callback` function 2041 to be invoked when receiving the response. 2042 >>> def callback_function(response): 2043 >>> pprint(response) 2044 >>> 2045 >>> thread = api.delete_user_authorizations(account_id, user_id, callback=callback_function) 2046 2047 :param callback function: The callback function 2048 for asynchronous request. (optional) 2049 :param str account_id: The external account number (int) or account ID Guid. (required) 2050 :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) 2051 :param UserAuthorizationsDeleteRequest user_authorizations_delete_request: 2052 :return: UserAuthorizationsDeleteResponse 2053 If the method is called asynchronously, 2054 returns the request thread. 2055 """ 2056 kwargs['_return_http_data_only'] = True 2057 if kwargs.get('callback'): 2058 return self.delete_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2059 else: 2060 (data) = self.delete_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2061 return data 2062 2063 def delete_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 2064 """ 2065 Creates ot updates user authorizations 2066 This method makes a synchronous HTTP request by default. To make an 2067 asynchronous HTTP request, please define a `callback` function 2068 to be invoked when receiving the response. 2069 >>> def callback_function(response): 2070 >>> pprint(response) 2071 >>> 2072 >>> thread = api.delete_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 2073 2074 :param callback function: The callback function 2075 for asynchronous request. (optional) 2076 :param str account_id: The external account number (int) or account ID Guid. (required) 2077 :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) 2078 :param UserAuthorizationsDeleteRequest user_authorizations_delete_request: 2079 :return: UserAuthorizationsDeleteResponse 2080 If the method is called asynchronously, 2081 returns the request thread. 2082 """ 2083 2084 all_params = ['account_id', 'user_id', 'user_authorizations_delete_request'] 2085 all_params.append('callback') 2086 all_params.append('_return_http_data_only') 2087 all_params.append('_preload_content') 2088 all_params.append('_request_timeout') 2089 2090 params = locals() 2091 for key, val in iteritems(params['kwargs']): 2092 if key not in all_params: 2093 raise TypeError( 2094 "Got an unexpected keyword argument '%s'" 2095 " to method delete_user_authorizations" % key 2096 ) 2097 params[key] = val 2098 del params['kwargs'] 2099 # verify the required parameter 'account_id' is set 2100 if ('account_id' not in params) or (params['account_id'] is None): 2101 raise ValueError("Missing the required parameter `account_id` when calling `delete_user_authorizations`") 2102 # verify the required parameter 'user_id' is set 2103 if ('user_id' not in params) or (params['user_id'] is None): 2104 raise ValueError("Missing the required parameter `user_id` when calling `delete_user_authorizations`") 2105 2106 2107 collection_formats = {} 2108 2109 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations'.replace('{format}', 'json') 2110 path_params = {} 2111 if 'account_id' in params: 2112 path_params['accountId'] = params['account_id'] 2113 if 'user_id' in params: 2114 path_params['userId'] = params['user_id'] 2115 2116 query_params = {} 2117 2118 header_params = {} 2119 2120 form_params = [] 2121 local_var_files = {} 2122 2123 body_params = None 2124 if 'user_authorizations_delete_request' in params: 2125 body_params = params['user_authorizations_delete_request'] 2126 # HTTP header `Accept` 2127 header_params['Accept'] = self.api_client.\ 2128 select_header_accept(['application/json']) 2129 2130 # Authentication setting 2131 auth_settings = [] 2132 2133 return self.api_client.call_api(resource_path, 'DELETE', 2134 path_params, 2135 query_params, 2136 header_params, 2137 body=body_params, 2138 post_params=form_params, 2139 files=local_var_files, 2140 response_type='UserAuthorizationsDeleteResponse', 2141 auth_settings=auth_settings, 2142 callback=params.get('callback'), 2143 _return_http_data_only=params.get('_return_http_data_only'), 2144 _preload_content=params.get('_preload_content', True), 2145 _request_timeout=params.get('_request_timeout'), 2146 collection_formats=collection_formats) 2147 2148 def get_account_identity_verification(self, account_id, **kwargs): 2149 """ 2150 Get the list of identity verification options for an account 2151 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/) 2152 This method makes a synchronous HTTP request by default. To make an 2153 asynchronous HTTP request, please define a `callback` function 2154 to be invoked when receiving the response. 2155 >>> def callback_function(response): 2156 >>> pprint(response) 2157 >>> 2158 >>> thread = api.get_account_identity_verification(account_id, callback=callback_function) 2159 2160 :param callback function: The callback function 2161 for asynchronous request. (optional) 2162 :param str account_id: The external account number (int) or account ID Guid. (required) 2163 :return: AccountIdentityVerificationResponse 2164 If the method is called asynchronously, 2165 returns the request thread. 2166 """ 2167 kwargs['_return_http_data_only'] = True 2168 if kwargs.get('callback'): 2169 return self.get_account_identity_verification_with_http_info(account_id, **kwargs) 2170 else: 2171 (data) = self.get_account_identity_verification_with_http_info(account_id, **kwargs) 2172 return data 2173 2174 def get_account_identity_verification_with_http_info(self, account_id, **kwargs): 2175 """ 2176 Get the list of identity verification options for an account 2177 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/) 2178 This method makes a synchronous HTTP request by default. To make an 2179 asynchronous HTTP request, please define a `callback` function 2180 to be invoked when receiving the response. 2181 >>> def callback_function(response): 2182 >>> pprint(response) 2183 >>> 2184 >>> thread = api.get_account_identity_verification_with_http_info(account_id, callback=callback_function) 2185 2186 :param callback function: The callback function 2187 for asynchronous request. (optional) 2188 :param str account_id: The external account number (int) or account ID Guid. (required) 2189 :return: AccountIdentityVerificationResponse 2190 If the method is called asynchronously, 2191 returns the request thread. 2192 """ 2193 2194 all_params = ['account_id'] 2195 all_params.append('callback') 2196 all_params.append('_return_http_data_only') 2197 all_params.append('_preload_content') 2198 all_params.append('_request_timeout') 2199 2200 params = locals() 2201 for key, val in iteritems(params['kwargs']): 2202 if key not in all_params: 2203 raise TypeError( 2204 "Got an unexpected keyword argument '%s'" 2205 " to method get_account_identity_verification" % key 2206 ) 2207 params[key] = val 2208 del params['kwargs'] 2209 # verify the required parameter 'account_id' is set 2210 if ('account_id' not in params) or (params['account_id'] is None): 2211 raise ValueError("Missing the required parameter `account_id` when calling `get_account_identity_verification`") 2212 2213 2214 collection_formats = {} 2215 2216 resource_path = '/v2.1/accounts/{accountId}/identity_verification'.replace('{format}', 'json') 2217 path_params = {} 2218 if 'account_id' in params: 2219 path_params['accountId'] = params['account_id'] 2220 2221 query_params = {} 2222 2223 header_params = {} 2224 2225 form_params = [] 2226 local_var_files = {} 2227 2228 body_params = None 2229 # HTTP header `Accept` 2230 header_params['Accept'] = self.api_client.\ 2231 select_header_accept(['application/json']) 2232 2233 # Authentication setting 2234 auth_settings = [] 2235 2236 return self.api_client.call_api(resource_path, 'GET', 2237 path_params, 2238 query_params, 2239 header_params, 2240 body=body_params, 2241 post_params=form_params, 2242 files=local_var_files, 2243 response_type='AccountIdentityVerificationResponse', 2244 auth_settings=auth_settings, 2245 callback=params.get('callback'), 2246 _return_http_data_only=params.get('_return_http_data_only'), 2247 _preload_content=params.get('_preload_content', True), 2248 _request_timeout=params.get('_request_timeout'), 2249 collection_formats=collection_formats) 2250 2251 def get_account_information(self, account_id, **kwargs): 2252 """ 2253 Retrieves the account information for the specified account. 2254 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. 2255 This method makes a synchronous HTTP request by default. To make an 2256 asynchronous HTTP request, please define a `callback` function 2257 to be invoked when receiving the response. 2258 >>> def callback_function(response): 2259 >>> pprint(response) 2260 >>> 2261 >>> thread = api.get_account_information(account_id, callback=callback_function) 2262 2263 :param callback function: The callback function 2264 for asynchronous request. (optional) 2265 :param str account_id: The external account number (int) or account ID Guid. (required) 2266 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 2267 :return: AccountInformation 2268 If the method is called asynchronously, 2269 returns the request thread. 2270 """ 2271 kwargs['_return_http_data_only'] = True 2272 if kwargs.get('callback'): 2273 return self.get_account_information_with_http_info(account_id, **kwargs) 2274 else: 2275 (data) = self.get_account_information_with_http_info(account_id, **kwargs) 2276 return data 2277 2278 def get_account_information_with_http_info(self, account_id, **kwargs): 2279 """ 2280 Retrieves the account information for the specified account. 2281 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. 2282 This method makes a synchronous HTTP request by default. To make an 2283 asynchronous HTTP request, please define a `callback` function 2284 to be invoked when receiving the response. 2285 >>> def callback_function(response): 2286 >>> pprint(response) 2287 >>> 2288 >>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function) 2289 2290 :param callback function: The callback function 2291 for asynchronous request. (optional) 2292 :param str account_id: The external account number (int) or account ID Guid. (required) 2293 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 2294 :return: AccountInformation 2295 If the method is called asynchronously, 2296 returns the request thread. 2297 """ 2298 2299 all_params = ['account_id', 'include_account_settings'] 2300 all_params.append('callback') 2301 all_params.append('_return_http_data_only') 2302 all_params.append('_preload_content') 2303 all_params.append('_request_timeout') 2304 2305 params = locals() 2306 for key, val in iteritems(params['kwargs']): 2307 if key not in all_params: 2308 raise TypeError( 2309 "Got an unexpected keyword argument '%s'" 2310 " to method get_account_information" % key 2311 ) 2312 params[key] = val 2313 del params['kwargs'] 2314 # verify the required parameter 'account_id' is set 2315 if ('account_id' not in params) or (params['account_id'] is None): 2316 raise ValueError("Missing the required parameter `account_id` when calling `get_account_information`") 2317 2318 2319 collection_formats = {} 2320 2321 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 2322 path_params = {} 2323 if 'account_id' in params: 2324 path_params['accountId'] = params['account_id'] 2325 2326 query_params = {} 2327 if 'include_account_settings' in params: 2328 query_params['include_account_settings'] = params['include_account_settings'] 2329 2330 header_params = {} 2331 2332 form_params = [] 2333 local_var_files = {} 2334 2335 body_params = None 2336 # HTTP header `Accept` 2337 header_params['Accept'] = self.api_client.\ 2338 select_header_accept(['application/json']) 2339 2340 # Authentication setting 2341 auth_settings = [] 2342 2343 return self.api_client.call_api(resource_path, 'GET', 2344 path_params, 2345 query_params, 2346 header_params, 2347 body=body_params, 2348 post_params=form_params, 2349 files=local_var_files, 2350 response_type='AccountInformation', 2351 auth_settings=auth_settings, 2352 callback=params.get('callback'), 2353 _return_http_data_only=params.get('_return_http_data_only'), 2354 _preload_content=params.get('_preload_content', True), 2355 _request_timeout=params.get('_request_timeout'), 2356 collection_formats=collection_formats) 2357 2358 def get_account_signature(self, account_id, signature_id, **kwargs): 2359 """ 2360 Returns information about a single signature by specifed signatureId. 2361 2362 This method makes a synchronous HTTP request by default. To make an 2363 asynchronous HTTP request, please define a `callback` function 2364 to be invoked when receiving the response. 2365 >>> def callback_function(response): 2366 >>> pprint(response) 2367 >>> 2368 >>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function) 2369 2370 :param callback function: The callback function 2371 for asynchronous request. (optional) 2372 :param str account_id: The external account number (int) or account ID Guid. (required) 2373 :param str signature_id: The ID of the signature being accessed. (required) 2374 :return: AccountSignature 2375 If the method is called asynchronously, 2376 returns the request thread. 2377 """ 2378 kwargs['_return_http_data_only'] = True 2379 if kwargs.get('callback'): 2380 return self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2381 else: 2382 (data) = self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2383 return data 2384 2385 def get_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 2386 """ 2387 Returns information about a single signature by specifed signatureId. 2388 2389 This method makes a synchronous HTTP request by default. To make an 2390 asynchronous HTTP request, please define a `callback` function 2391 to be invoked when receiving the response. 2392 >>> def callback_function(response): 2393 >>> pprint(response) 2394 >>> 2395 >>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 2396 2397 :param callback function: The callback function 2398 for asynchronous request. (optional) 2399 :param str account_id: The external account number (int) or account ID Guid. (required) 2400 :param str signature_id: The ID of the signature being accessed. (required) 2401 :return: AccountSignature 2402 If the method is called asynchronously, 2403 returns the request thread. 2404 """ 2405 2406 all_params = ['account_id', 'signature_id'] 2407 all_params.append('callback') 2408 all_params.append('_return_http_data_only') 2409 all_params.append('_preload_content') 2410 all_params.append('_request_timeout') 2411 2412 params = locals() 2413 for key, val in iteritems(params['kwargs']): 2414 if key not in all_params: 2415 raise TypeError( 2416 "Got an unexpected keyword argument '%s'" 2417 " to method get_account_signature" % key 2418 ) 2419 params[key] = val 2420 del params['kwargs'] 2421 # verify the required parameter 'account_id' is set 2422 if ('account_id' not in params) or (params['account_id'] is None): 2423 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature`") 2424 # verify the required parameter 'signature_id' is set 2425 if ('signature_id' not in params) or (params['signature_id'] is None): 2426 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature`") 2427 2428 2429 collection_formats = {} 2430 2431 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 2432 path_params = {} 2433 if 'account_id' in params: 2434 path_params['accountId'] = params['account_id'] 2435 if 'signature_id' in params: 2436 path_params['signatureId'] = params['signature_id'] 2437 2438 query_params = {} 2439 2440 header_params = {} 2441 2442 form_params = [] 2443 local_var_files = {} 2444 2445 body_params = None 2446 # HTTP header `Accept` 2447 header_params['Accept'] = self.api_client.\ 2448 select_header_accept(['application/json']) 2449 2450 # Authentication setting 2451 auth_settings = [] 2452 2453 return self.api_client.call_api(resource_path, 'GET', 2454 path_params, 2455 query_params, 2456 header_params, 2457 body=body_params, 2458 post_params=form_params, 2459 files=local_var_files, 2460 response_type='AccountSignature', 2461 auth_settings=auth_settings, 2462 callback=params.get('callback'), 2463 _return_http_data_only=params.get('_return_http_data_only'), 2464 _preload_content=params.get('_preload_content', True), 2465 _request_timeout=params.get('_request_timeout'), 2466 collection_formats=collection_formats) 2467 2468 def get_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 2469 """ 2470 Returns a signature, initials, or stamps image. 2471 2472 This method makes a synchronous HTTP request by default. To make an 2473 asynchronous HTTP request, please define a `callback` function 2474 to be invoked when receiving the response. 2475 >>> def callback_function(response): 2476 >>> pprint(response) 2477 >>> 2478 >>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 2479 2480 :param callback function: The callback function 2481 for asynchronous request. (optional) 2482 :param str account_id: The external account number (int) or account ID Guid. (required) 2483 :param str image_type: One of **signature_image** or **initials_image**. (required) 2484 :param str signature_id: The ID of the signature being accessed. (required) 2485 :param str include_chrome: 2486 :return: file 2487 If the method is called asynchronously, 2488 returns the request thread. 2489 """ 2490 kwargs['_return_http_data_only'] = True 2491 if kwargs.get('callback'): 2492 return self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2493 else: 2494 (data) = self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2495 return data 2496 2497 def get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 2498 """ 2499 Returns a signature, initials, or stamps image. 2500 2501 This method makes a synchronous HTTP request by default. To make an 2502 asynchronous HTTP request, please define a `callback` function 2503 to be invoked when receiving the response. 2504 >>> def callback_function(response): 2505 >>> pprint(response) 2506 >>> 2507 >>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 2508 2509 :param callback function: The callback function 2510 for asynchronous request. (optional) 2511 :param str account_id: The external account number (int) or account ID Guid. (required) 2512 :param str image_type: One of **signature_image** or **initials_image**. (required) 2513 :param str signature_id: The ID of the signature being accessed. (required) 2514 :param str include_chrome: 2515 :return: file 2516 If the method is called asynchronously, 2517 returns the request thread. 2518 """ 2519 2520 all_params = ['account_id', 'image_type', 'signature_id', 'include_chrome'] 2521 all_params.append('callback') 2522 all_params.append('_return_http_data_only') 2523 all_params.append('_preload_content') 2524 all_params.append('_request_timeout') 2525 2526 params = locals() 2527 for key, val in iteritems(params['kwargs']): 2528 if key not in all_params: 2529 raise TypeError( 2530 "Got an unexpected keyword argument '%s'" 2531 " to method get_account_signature_image" % key 2532 ) 2533 params[key] = val 2534 del params['kwargs'] 2535 # verify the required parameter 'account_id' is set 2536 if ('account_id' not in params) or (params['account_id'] is None): 2537 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature_image`") 2538 # verify the required parameter 'image_type' is set 2539 if ('image_type' not in params) or (params['image_type'] is None): 2540 raise ValueError("Missing the required parameter `image_type` when calling `get_account_signature_image`") 2541 # verify the required parameter 'signature_id' is set 2542 if ('signature_id' not in params) or (params['signature_id'] is None): 2543 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature_image`") 2544 2545 2546 collection_formats = {} 2547 2548 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 2549 path_params = {} 2550 if 'account_id' in params: 2551 path_params['accountId'] = params['account_id'] 2552 if 'image_type' in params: 2553 path_params['imageType'] = params['image_type'] 2554 if 'signature_id' in params: 2555 path_params['signatureId'] = params['signature_id'] 2556 2557 query_params = {} 2558 if 'include_chrome' in params: 2559 query_params['include_chrome'] = params['include_chrome'] 2560 2561 header_params = {} 2562 2563 form_params = [] 2564 local_var_files = {} 2565 2566 body_params = None 2567 # HTTP header `Accept` 2568 header_params['Accept'] = self.api_client.\ 2569 select_header_accept(['image/gif']) 2570 2571 # Authentication setting 2572 auth_settings = [] 2573 2574 return self.api_client.call_api(resource_path, 'GET', 2575 path_params, 2576 query_params, 2577 header_params, 2578 body=body_params, 2579 post_params=form_params, 2580 files=local_var_files, 2581 response_type='file', 2582 auth_settings=auth_settings, 2583 callback=params.get('callback'), 2584 _return_http_data_only=params.get('_return_http_data_only'), 2585 _preload_content=params.get('_preload_content', True), 2586 _request_timeout=params.get('_request_timeout'), 2587 collection_formats=collection_formats) 2588 2589 def get_account_signatures(self, account_id, **kwargs): 2590 """ 2591 Returns the managed signature definitions for the account 2592 2593 This method makes a synchronous HTTP request by default. To make an 2594 asynchronous HTTP request, please define a `callback` function 2595 to be invoked when receiving the response. 2596 >>> def callback_function(response): 2597 >>> pprint(response) 2598 >>> 2599 >>> thread = api.get_account_signatures(account_id, callback=callback_function) 2600 2601 :param callback function: The callback function 2602 for asynchronous request. (optional) 2603 :param str account_id: The external account number (int) or account ID Guid. (required) 2604 :param str stamp_format: 2605 :param str stamp_name: 2606 :param str stamp_type: 2607 :return: AccountSignaturesInformation 2608 If the method is called asynchronously, 2609 returns the request thread. 2610 """ 2611 kwargs['_return_http_data_only'] = True 2612 if kwargs.get('callback'): 2613 return self.get_account_signatures_with_http_info(account_id, **kwargs) 2614 else: 2615 (data) = self.get_account_signatures_with_http_info(account_id, **kwargs) 2616 return data 2617 2618 def get_account_signatures_with_http_info(self, account_id, **kwargs): 2619 """ 2620 Returns the managed signature definitions for the account 2621 2622 This method makes a synchronous HTTP request by default. To make an 2623 asynchronous HTTP request, please define a `callback` function 2624 to be invoked when receiving the response. 2625 >>> def callback_function(response): 2626 >>> pprint(response) 2627 >>> 2628 >>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function) 2629 2630 :param callback function: The callback function 2631 for asynchronous request. (optional) 2632 :param str account_id: The external account number (int) or account ID Guid. (required) 2633 :param str stamp_format: 2634 :param str stamp_name: 2635 :param str stamp_type: 2636 :return: AccountSignaturesInformation 2637 If the method is called asynchronously, 2638 returns the request thread. 2639 """ 2640 2641 all_params = ['account_id', 'stamp_format', 'stamp_name', 'stamp_type'] 2642 all_params.append('callback') 2643 all_params.append('_return_http_data_only') 2644 all_params.append('_preload_content') 2645 all_params.append('_request_timeout') 2646 2647 params = locals() 2648 for key, val in iteritems(params['kwargs']): 2649 if key not in all_params: 2650 raise TypeError( 2651 "Got an unexpected keyword argument '%s'" 2652 " to method get_account_signatures" % key 2653 ) 2654 params[key] = val 2655 del params['kwargs'] 2656 # verify the required parameter 'account_id' is set 2657 if ('account_id' not in params) or (params['account_id'] is None): 2658 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signatures`") 2659 2660 2661 collection_formats = {} 2662 2663 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 2664 path_params = {} 2665 if 'account_id' in params: 2666 path_params['accountId'] = params['account_id'] 2667 2668 query_params = {} 2669 if 'stamp_format' in params: 2670 query_params['stamp_format'] = params['stamp_format'] 2671 if 'stamp_name' in params: 2672 query_params['stamp_name'] = params['stamp_name'] 2673 if 'stamp_type' in params: 2674 query_params['stamp_type'] = params['stamp_type'] 2675 2676 header_params = {} 2677 2678 form_params = [] 2679 local_var_files = {} 2680 2681 body_params = None 2682 # HTTP header `Accept` 2683 header_params['Accept'] = self.api_client.\ 2684 select_header_accept(['application/json']) 2685 2686 # Authentication setting 2687 auth_settings = [] 2688 2689 return self.api_client.call_api(resource_path, 'GET', 2690 path_params, 2691 query_params, 2692 header_params, 2693 body=body_params, 2694 post_params=form_params, 2695 files=local_var_files, 2696 response_type='AccountSignaturesInformation', 2697 auth_settings=auth_settings, 2698 callback=params.get('callback'), 2699 _return_http_data_only=params.get('_return_http_data_only'), 2700 _preload_content=params.get('_preload_content', True), 2701 _request_timeout=params.get('_request_timeout'), 2702 collection_formats=collection_formats) 2703 2704 def get_account_tab_settings(self, account_id, **kwargs): 2705 """ 2706 Returns tab settings list for specified account 2707 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2708 This method makes a synchronous HTTP request by default. To make an 2709 asynchronous HTTP request, please define a `callback` function 2710 to be invoked when receiving the response. 2711 >>> def callback_function(response): 2712 >>> pprint(response) 2713 >>> 2714 >>> thread = api.get_account_tab_settings(account_id, callback=callback_function) 2715 2716 :param callback function: The callback function 2717 for asynchronous request. (optional) 2718 :param str account_id: The external account number (int) or account ID Guid. (required) 2719 :return: TabAccountSettings 2720 If the method is called asynchronously, 2721 returns the request thread. 2722 """ 2723 kwargs['_return_http_data_only'] = True 2724 if kwargs.get('callback'): 2725 return self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2726 else: 2727 (data) = self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2728 return data 2729 2730 def get_account_tab_settings_with_http_info(self, account_id, **kwargs): 2731 """ 2732 Returns tab settings list for specified account 2733 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2734 This method makes a synchronous HTTP request by default. To make an 2735 asynchronous HTTP request, please define a `callback` function 2736 to be invoked when receiving the response. 2737 >>> def callback_function(response): 2738 >>> pprint(response) 2739 >>> 2740 >>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function) 2741 2742 :param callback function: The callback function 2743 for asynchronous request. (optional) 2744 :param str account_id: The external account number (int) or account ID Guid. (required) 2745 :return: TabAccountSettings 2746 If the method is called asynchronously, 2747 returns the request thread. 2748 """ 2749 2750 all_params = ['account_id'] 2751 all_params.append('callback') 2752 all_params.append('_return_http_data_only') 2753 all_params.append('_preload_content') 2754 all_params.append('_request_timeout') 2755 2756 params = locals() 2757 for key, val in iteritems(params['kwargs']): 2758 if key not in all_params: 2759 raise TypeError( 2760 "Got an unexpected keyword argument '%s'" 2761 " to method get_account_tab_settings" % key 2762 ) 2763 params[key] = val 2764 del params['kwargs'] 2765 # verify the required parameter 'account_id' is set 2766 if ('account_id' not in params) or (params['account_id'] is None): 2767 raise ValueError("Missing the required parameter `account_id` when calling `get_account_tab_settings`") 2768 2769 2770 collection_formats = {} 2771 2772 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 2773 path_params = {} 2774 if 'account_id' in params: 2775 path_params['accountId'] = params['account_id'] 2776 2777 query_params = {} 2778 2779 header_params = {} 2780 2781 form_params = [] 2782 local_var_files = {} 2783 2784 body_params = None 2785 # HTTP header `Accept` 2786 header_params['Accept'] = self.api_client.\ 2787 select_header_accept(['application/json']) 2788 2789 # Authentication setting 2790 auth_settings = [] 2791 2792 return self.api_client.call_api(resource_path, 'GET', 2793 path_params, 2794 query_params, 2795 header_params, 2796 body=body_params, 2797 post_params=form_params, 2798 files=local_var_files, 2799 response_type='TabAccountSettings', 2800 auth_settings=auth_settings, 2801 callback=params.get('callback'), 2802 _return_http_data_only=params.get('_return_http_data_only'), 2803 _preload_content=params.get('_preload_content', True), 2804 _request_timeout=params.get('_request_timeout'), 2805 collection_formats=collection_formats) 2806 2807 def get_agent_user_authorizations(self, account_id, user_id, **kwargs): 2808 """ 2809 Returns the agent user authorizations 2810 This method makes a synchronous HTTP request by default. To make an 2811 asynchronous HTTP request, please define a `callback` function 2812 to be invoked when receiving the response. 2813 >>> def callback_function(response): 2814 >>> pprint(response) 2815 >>> 2816 >>> thread = api.get_agent_user_authorizations(account_id, user_id, callback=callback_function) 2817 2818 :param callback function: The callback function 2819 for asynchronous request. (optional) 2820 :param str account_id: The external account number (int) or account ID Guid. (required) 2821 :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) 2822 :param str active_only: 2823 :param str count: 2824 :param str email_substring: Part (substring) of email we are searching for. 2825 :param str include_closed_users: 2826 :param str permissions: 2827 :param str start_position: 2828 :param str user_name_substring: 2829 :return: UserAuthorizations 2830 If the method is called asynchronously, 2831 returns the request thread. 2832 """ 2833 kwargs['_return_http_data_only'] = True 2834 if kwargs.get('callback'): 2835 return self.get_agent_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2836 else: 2837 (data) = self.get_agent_user_authorizations_with_http_info(account_id, user_id, **kwargs) 2838 return data 2839 2840 def get_agent_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 2841 """ 2842 Returns the agent user authorizations 2843 This method makes a synchronous HTTP request by default. To make an 2844 asynchronous HTTP request, please define a `callback` function 2845 to be invoked when receiving the response. 2846 >>> def callback_function(response): 2847 >>> pprint(response) 2848 >>> 2849 >>> thread = api.get_agent_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 2850 2851 :param callback function: The callback function 2852 for asynchronous request. (optional) 2853 :param str account_id: The external account number (int) or account ID Guid. (required) 2854 :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) 2855 :param str active_only: 2856 :param str count: 2857 :param str email_substring: Part (substring) of email we are searching for. 2858 :param str include_closed_users: 2859 :param str permissions: 2860 :param str start_position: 2861 :param str user_name_substring: 2862 :return: UserAuthorizations 2863 If the method is called asynchronously, 2864 returns the request thread. 2865 """ 2866 2867 all_params = ['account_id', 'user_id', 'active_only', 'count', 'email_substring', 'include_closed_users', 'permissions', 'start_position', 'user_name_substring'] 2868 all_params.append('callback') 2869 all_params.append('_return_http_data_only') 2870 all_params.append('_preload_content') 2871 all_params.append('_request_timeout') 2872 2873 params = locals() 2874 for key, val in iteritems(params['kwargs']): 2875 if key not in all_params: 2876 raise TypeError( 2877 "Got an unexpected keyword argument '%s'" 2878 " to method get_agent_user_authorizations" % key 2879 ) 2880 params[key] = val 2881 del params['kwargs'] 2882 # verify the required parameter 'account_id' is set 2883 if ('account_id' not in params) or (params['account_id'] is None): 2884 raise ValueError("Missing the required parameter `account_id` when calling `get_agent_user_authorizations`") 2885 # verify the required parameter 'user_id' is set 2886 if ('user_id' not in params) or (params['user_id'] is None): 2887 raise ValueError("Missing the required parameter `user_id` when calling `get_agent_user_authorizations`") 2888 2889 2890 collection_formats = {} 2891 2892 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations/agent'.replace('{format}', 'json') 2893 path_params = {} 2894 if 'account_id' in params: 2895 path_params['accountId'] = params['account_id'] 2896 if 'user_id' in params: 2897 path_params['userId'] = params['user_id'] 2898 2899 query_params = {} 2900 if 'active_only' in params: 2901 query_params['active_only'] = params['active_only'] 2902 if 'count' in params: 2903 query_params['count'] = params['count'] 2904 if 'email_substring' in params: 2905 query_params['email_substring'] = params['email_substring'] 2906 if 'include_closed_users' in params: 2907 query_params['include_closed_users'] = params['include_closed_users'] 2908 if 'permissions' in params: 2909 query_params['permissions'] = params['permissions'] 2910 if 'start_position' in params: 2911 query_params['start_position'] = params['start_position'] 2912 if 'user_name_substring' in params: 2913 query_params['user_name_substring'] = params['user_name_substring'] 2914 2915 header_params = {} 2916 2917 form_params = [] 2918 local_var_files = {} 2919 2920 body_params = None 2921 # HTTP header `Accept` 2922 header_params['Accept'] = self.api_client.\ 2923 select_header_accept(['application/json']) 2924 2925 # Authentication setting 2926 auth_settings = [] 2927 2928 return self.api_client.call_api(resource_path, 'GET', 2929 path_params, 2930 query_params, 2931 header_params, 2932 body=body_params, 2933 post_params=form_params, 2934 files=local_var_files, 2935 response_type='UserAuthorizations', 2936 auth_settings=auth_settings, 2937 callback=params.get('callback'), 2938 _return_http_data_only=params.get('_return_http_data_only'), 2939 _preload_content=params.get('_preload_content', True), 2940 _request_timeout=params.get('_request_timeout'), 2941 collection_formats=collection_formats) 2942 2943 def get_all_payment_gateway_accounts(self, account_id, **kwargs): 2944 """ 2945 Get all payment gateway account for the provided accountId 2946 This method returns a list of payment gateway accounts and basic information about them. 2947 This method makes a synchronous HTTP request by default. To make an 2948 asynchronous HTTP request, please define a `callback` function 2949 to be invoked when receiving the response. 2950 >>> def callback_function(response): 2951 >>> pprint(response) 2952 >>> 2953 >>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function) 2954 2955 :param callback function: The callback function 2956 for asynchronous request. (optional) 2957 :param str account_id: The external account number (int) or account ID Guid. (required) 2958 :return: PaymentGatewayAccountsInfo 2959 If the method is called asynchronously, 2960 returns the request thread. 2961 """ 2962 kwargs['_return_http_data_only'] = True 2963 if kwargs.get('callback'): 2964 return self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2965 else: 2966 (data) = self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2967 return data 2968 2969 def get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs): 2970 """ 2971 Get all payment gateway account for the provided accountId 2972 This method returns a list of payment gateway accounts and basic information about them. 2973 This method makes a synchronous HTTP request by default. To make an 2974 asynchronous HTTP request, please define a `callback` function 2975 to be invoked when receiving the response. 2976 >>> def callback_function(response): 2977 >>> pprint(response) 2978 >>> 2979 >>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function) 2980 2981 :param callback function: The callback function 2982 for asynchronous request. (optional) 2983 :param str account_id: The external account number (int) or account ID Guid. (required) 2984 :return: PaymentGatewayAccountsInfo 2985 If the method is called asynchronously, 2986 returns the request thread. 2987 """ 2988 2989 all_params = ['account_id'] 2990 all_params.append('callback') 2991 all_params.append('_return_http_data_only') 2992 all_params.append('_preload_content') 2993 all_params.append('_request_timeout') 2994 2995 params = locals() 2996 for key, val in iteritems(params['kwargs']): 2997 if key not in all_params: 2998 raise TypeError( 2999 "Got an unexpected keyword argument '%s'" 3000 " to method get_all_payment_gateway_accounts" % key 3001 ) 3002 params[key] = val 3003 del params['kwargs'] 3004 # verify the required parameter 'account_id' is set 3005 if ('account_id' not in params) or (params['account_id'] is None): 3006 raise ValueError("Missing the required parameter `account_id` when calling `get_all_payment_gateway_accounts`") 3007 3008 3009 collection_formats = {} 3010 3011 resource_path = '/v2.1/accounts/{accountId}/payment_gateway_accounts'.replace('{format}', 'json') 3012 path_params = {} 3013 if 'account_id' in params: 3014 path_params['accountId'] = params['account_id'] 3015 3016 query_params = {} 3017 3018 header_params = {} 3019 3020 form_params = [] 3021 local_var_files = {} 3022 3023 body_params = None 3024 # HTTP header `Accept` 3025 header_params['Accept'] = self.api_client.\ 3026 select_header_accept(['application/json']) 3027 3028 # Authentication setting 3029 auth_settings = [] 3030 3031 return self.api_client.call_api(resource_path, 'GET', 3032 path_params, 3033 query_params, 3034 header_params, 3035 body=body_params, 3036 post_params=form_params, 3037 files=local_var_files, 3038 response_type='PaymentGatewayAccountsInfo', 3039 auth_settings=auth_settings, 3040 callback=params.get('callback'), 3041 _return_http_data_only=params.get('_return_http_data_only'), 3042 _preload_content=params.get('_preload_content', True), 3043 _request_timeout=params.get('_request_timeout'), 3044 collection_formats=collection_formats) 3045 3046 def get_billing_charges(self, account_id, **kwargs): 3047 """ 3048 Gets list of recurring and usage charges for the account. 3049 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 3050 This method makes a synchronous HTTP request by default. To make an 3051 asynchronous HTTP request, please define a `callback` function 3052 to be invoked when receiving the response. 3053 >>> def callback_function(response): 3054 >>> pprint(response) 3055 >>> 3056 >>> thread = api.get_billing_charges(account_id, callback=callback_function) 3057 3058 :param callback function: The callback function 3059 for asynchronous request. (optional) 3060 :param str account_id: The external account number (int) or account ID Guid. (required) 3061 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3062 :return: BillingChargeResponse 3063 If the method is called asynchronously, 3064 returns the request thread. 3065 """ 3066 kwargs['_return_http_data_only'] = True 3067 if kwargs.get('callback'): 3068 return self.get_billing_charges_with_http_info(account_id, **kwargs) 3069 else: 3070 (data) = self.get_billing_charges_with_http_info(account_id, **kwargs) 3071 return data 3072 3073 def get_billing_charges_with_http_info(self, account_id, **kwargs): 3074 """ 3075 Gets list of recurring and usage charges for the account. 3076 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 3077 This method makes a synchronous HTTP request by default. To make an 3078 asynchronous HTTP request, please define a `callback` function 3079 to be invoked when receiving the response. 3080 >>> def callback_function(response): 3081 >>> pprint(response) 3082 >>> 3083 >>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function) 3084 3085 :param callback function: The callback function 3086 for asynchronous request. (optional) 3087 :param str account_id: The external account number (int) or account ID Guid. (required) 3088 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3089 :return: BillingChargeResponse 3090 If the method is called asynchronously, 3091 returns the request thread. 3092 """ 3093 3094 all_params = ['account_id', 'include_charges'] 3095 all_params.append('callback') 3096 all_params.append('_return_http_data_only') 3097 all_params.append('_preload_content') 3098 all_params.append('_request_timeout') 3099 3100 params = locals() 3101 for key, val in iteritems(params['kwargs']): 3102 if key not in all_params: 3103 raise TypeError( 3104 "Got an unexpected keyword argument '%s'" 3105 " to method get_billing_charges" % key 3106 ) 3107 params[key] = val 3108 del params['kwargs'] 3109 # verify the required parameter 'account_id' is set 3110 if ('account_id' not in params) or (params['account_id'] is None): 3111 raise ValueError("Missing the required parameter `account_id` when calling `get_billing_charges`") 3112 3113 3114 collection_formats = {} 3115 3116 resource_path = '/v2.1/accounts/{accountId}/billing_charges'.replace('{format}', 'json') 3117 path_params = {} 3118 if 'account_id' in params: 3119 path_params['accountId'] = params['account_id'] 3120 3121 query_params = {} 3122 if 'include_charges' in params: 3123 query_params['include_charges'] = params['include_charges'] 3124 3125 header_params = {} 3126 3127 form_params = [] 3128 local_var_files = {} 3129 3130 body_params = None 3131 # HTTP header `Accept` 3132 header_params['Accept'] = self.api_client.\ 3133 select_header_accept(['application/json']) 3134 3135 # Authentication setting 3136 auth_settings = [] 3137 3138 return self.api_client.call_api(resource_path, 'GET', 3139 path_params, 3140 query_params, 3141 header_params, 3142 body=body_params, 3143 post_params=form_params, 3144 files=local_var_files, 3145 response_type='BillingChargeResponse', 3146 auth_settings=auth_settings, 3147 callback=params.get('callback'), 3148 _return_http_data_only=params.get('_return_http_data_only'), 3149 _preload_content=params.get('_preload_content', True), 3150 _request_timeout=params.get('_request_timeout'), 3151 collection_formats=collection_formats) 3152 3153 def get_brand(self, account_id, brand_id, **kwargs): 3154 """ 3155 Get information for a specific brand. 3156 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**). 3157 This method makes a synchronous HTTP request by default. To make an 3158 asynchronous HTTP request, please define a `callback` function 3159 to be invoked when receiving the response. 3160 >>> def callback_function(response): 3161 >>> pprint(response) 3162 >>> 3163 >>> thread = api.get_brand(account_id, brand_id, callback=callback_function) 3164 3165 :param callback function: The callback function 3166 for asynchronous request. (optional) 3167 :param str account_id: The external account number (int) or account ID Guid. (required) 3168 :param str brand_id: The unique identifier of a brand. (required) 3169 :param str include_external_references: 3170 :param str include_logos: 3171 :return: Brand 3172 If the method is called asynchronously, 3173 returns the request thread. 3174 """ 3175 kwargs['_return_http_data_only'] = True 3176 if kwargs.get('callback'): 3177 return self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3178 else: 3179 (data) = self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3180 return data 3181 3182 def get_brand_with_http_info(self, account_id, brand_id, **kwargs): 3183 """ 3184 Get information for a specific brand. 3185 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**). 3186 This method makes a synchronous HTTP request by default. To make an 3187 asynchronous HTTP request, please define a `callback` function 3188 to be invoked when receiving the response. 3189 >>> def callback_function(response): 3190 >>> pprint(response) 3191 >>> 3192 >>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function) 3193 3194 :param callback function: The callback function 3195 for asynchronous request. (optional) 3196 :param str account_id: The external account number (int) or account ID Guid. (required) 3197 :param str brand_id: The unique identifier of a brand. (required) 3198 :param str include_external_references: 3199 :param str include_logos: 3200 :return: Brand 3201 If the method is called asynchronously, 3202 returns the request thread. 3203 """ 3204 3205 all_params = ['account_id', 'brand_id', 'include_external_references', 'include_logos'] 3206 all_params.append('callback') 3207 all_params.append('_return_http_data_only') 3208 all_params.append('_preload_content') 3209 all_params.append('_request_timeout') 3210 3211 params = locals() 3212 for key, val in iteritems(params['kwargs']): 3213 if key not in all_params: 3214 raise TypeError( 3215 "Got an unexpected keyword argument '%s'" 3216 " to method get_brand" % key 3217 ) 3218 params[key] = val 3219 del params['kwargs'] 3220 # verify the required parameter 'account_id' is set 3221 if ('account_id' not in params) or (params['account_id'] is None): 3222 raise ValueError("Missing the required parameter `account_id` when calling `get_brand`") 3223 # verify the required parameter 'brand_id' is set 3224 if ('brand_id' not in params) or (params['brand_id'] is None): 3225 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand`") 3226 3227 3228 collection_formats = {} 3229 3230 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 3231 path_params = {} 3232 if 'account_id' in params: 3233 path_params['accountId'] = params['account_id'] 3234 if 'brand_id' in params: 3235 path_params['brandId'] = params['brand_id'] 3236 3237 query_params = {} 3238 if 'include_external_references' in params: 3239 query_params['include_external_references'] = params['include_external_references'] 3240 if 'include_logos' in params: 3241 query_params['include_logos'] = params['include_logos'] 3242 3243 header_params = {} 3244 3245 form_params = [] 3246 local_var_files = {} 3247 3248 body_params = None 3249 # HTTP header `Accept` 3250 header_params['Accept'] = self.api_client.\ 3251 select_header_accept(['application/json']) 3252 3253 # Authentication setting 3254 auth_settings = [] 3255 3256 return self.api_client.call_api(resource_path, 'GET', 3257 path_params, 3258 query_params, 3259 header_params, 3260 body=body_params, 3261 post_params=form_params, 3262 files=local_var_files, 3263 response_type='Brand', 3264 auth_settings=auth_settings, 3265 callback=params.get('callback'), 3266 _return_http_data_only=params.get('_return_http_data_only'), 3267 _preload_content=params.get('_preload_content', True), 3268 _request_timeout=params.get('_request_timeout'), 3269 collection_formats=collection_formats) 3270 3271 def get_brand_export_file(self, account_id, brand_id, **kwargs): 3272 """ 3273 Export a specific brand. 3274 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**). 3275 This method makes a synchronous HTTP request by default. To make an 3276 asynchronous HTTP request, please define a `callback` function 3277 to be invoked when receiving the response. 3278 >>> def callback_function(response): 3279 >>> pprint(response) 3280 >>> 3281 >>> thread = api.get_brand_export_file(account_id, brand_id, callback=callback_function) 3282 3283 :param callback function: The callback function 3284 for asynchronous request. (optional) 3285 :param str account_id: The external account number (int) or account ID Guid. (required) 3286 :param str brand_id: The unique identifier of a brand. (required) 3287 :return: None 3288 If the method is called asynchronously, 3289 returns the request thread. 3290 """ 3291 kwargs['_return_http_data_only'] = True 3292 if kwargs.get('callback'): 3293 return self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3294 else: 3295 (data) = self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3296 return data 3297 3298 def get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs): 3299 """ 3300 Export a specific brand. 3301 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**). 3302 This method makes a synchronous HTTP request by default. To make an 3303 asynchronous HTTP request, please define a `callback` function 3304 to be invoked when receiving the response. 3305 >>> def callback_function(response): 3306 >>> pprint(response) 3307 >>> 3308 >>> thread = api.get_brand_export_file_with_http_info(account_id, brand_id, callback=callback_function) 3309 3310 :param callback function: The callback function 3311 for asynchronous request. (optional) 3312 :param str account_id: The external account number (int) or account ID Guid. (required) 3313 :param str brand_id: The unique identifier of a brand. (required) 3314 :return: None 3315 If the method is called asynchronously, 3316 returns the request thread. 3317 """ 3318 3319 all_params = ['account_id', 'brand_id'] 3320 all_params.append('callback') 3321 all_params.append('_return_http_data_only') 3322 all_params.append('_preload_content') 3323 all_params.append('_request_timeout') 3324 3325 params = locals() 3326 for key, val in iteritems(params['kwargs']): 3327 if key not in all_params: 3328 raise TypeError( 3329 "Got an unexpected keyword argument '%s'" 3330 " to method get_brand_export_file" % key 3331 ) 3332 params[key] = val 3333 del params['kwargs'] 3334 # verify the required parameter 'account_id' is set 3335 if ('account_id' not in params) or (params['account_id'] is None): 3336 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_export_file`") 3337 # verify the required parameter 'brand_id' is set 3338 if ('brand_id' not in params) or (params['brand_id'] is None): 3339 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_export_file`") 3340 3341 3342 collection_formats = {} 3343 3344 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/file'.replace('{format}', 'json') 3345 path_params = {} 3346 if 'account_id' in params: 3347 path_params['accountId'] = params['account_id'] 3348 if 'brand_id' in params: 3349 path_params['brandId'] = params['brand_id'] 3350 3351 query_params = {} 3352 3353 header_params = {} 3354 3355 form_params = [] 3356 local_var_files = {} 3357 3358 body_params = None 3359 # HTTP header `Accept` 3360 header_params['Accept'] = self.api_client.\ 3361 select_header_accept(['application/json']) 3362 3363 # Authentication setting 3364 auth_settings = [] 3365 3366 return self.api_client.call_api(resource_path, 'GET', 3367 path_params, 3368 query_params, 3369 header_params, 3370 body=body_params, 3371 post_params=form_params, 3372 files=local_var_files, 3373 response_type=None, 3374 auth_settings=auth_settings, 3375 callback=params.get('callback'), 3376 _return_http_data_only=params.get('_return_http_data_only'), 3377 _preload_content=params.get('_preload_content', True), 3378 _request_timeout=params.get('_request_timeout'), 3379 collection_formats=collection_formats) 3380 3381 def get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 3382 """ 3383 Obtains the specified image for a brand. 3384 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**). 3385 This method makes a synchronous HTTP request by default. To make an 3386 asynchronous HTTP request, please define a `callback` function 3387 to be invoked when receiving the response. 3388 >>> def callback_function(response): 3389 >>> pprint(response) 3390 >>> 3391 >>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 3392 3393 :param callback function: The callback function 3394 for asynchronous request. (optional) 3395 :param str account_id: The external account number (int) or account ID Guid. (required) 3396 :param str brand_id: The unique identifier of a brand. (required) 3397 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3398 :return: file 3399 If the method is called asynchronously, 3400 returns the request thread. 3401 """ 3402 kwargs['_return_http_data_only'] = True 3403 if kwargs.get('callback'): 3404 return self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3405 else: 3406 (data) = self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3407 return data 3408 3409 def get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 3410 """ 3411 Obtains the specified image for a brand. 3412 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**). 3413 This method makes a synchronous HTTP request by default. To make an 3414 asynchronous HTTP request, please define a `callback` function 3415 to be invoked when receiving the response. 3416 >>> def callback_function(response): 3417 >>> pprint(response) 3418 >>> 3419 >>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 3420 3421 :param callback function: The callback function 3422 for asynchronous request. (optional) 3423 :param str account_id: The external account number (int) or account ID Guid. (required) 3424 :param str brand_id: The unique identifier of a brand. (required) 3425 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3426 :return: file 3427 If the method is called asynchronously, 3428 returns the request thread. 3429 """ 3430 3431 all_params = ['account_id', 'brand_id', 'logo_type'] 3432 all_params.append('callback') 3433 all_params.append('_return_http_data_only') 3434 all_params.append('_preload_content') 3435 all_params.append('_request_timeout') 3436 3437 params = locals() 3438 for key, val in iteritems(params['kwargs']): 3439 if key not in all_params: 3440 raise TypeError( 3441 "Got an unexpected keyword argument '%s'" 3442 " to method get_brand_logo_by_type" % key 3443 ) 3444 params[key] = val 3445 del params['kwargs'] 3446 # verify the required parameter 'account_id' is set 3447 if ('account_id' not in params) or (params['account_id'] is None): 3448 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_logo_by_type`") 3449 # verify the required parameter 'brand_id' is set 3450 if ('brand_id' not in params) or (params['brand_id'] is None): 3451 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_logo_by_type`") 3452 # verify the required parameter 'logo_type' is set 3453 if ('logo_type' not in params) or (params['logo_type'] is None): 3454 raise ValueError("Missing the required parameter `logo_type` when calling `get_brand_logo_by_type`") 3455 3456 3457 collection_formats = {} 3458 3459 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 3460 path_params = {} 3461 if 'account_id' in params: 3462 path_params['accountId'] = params['account_id'] 3463 if 'brand_id' in params: 3464 path_params['brandId'] = params['brand_id'] 3465 if 'logo_type' in params: 3466 path_params['logoType'] = params['logo_type'] 3467 3468 query_params = {} 3469 3470 header_params = {} 3471 3472 form_params = [] 3473 local_var_files = {} 3474 3475 body_params = None 3476 # HTTP header `Accept` 3477 header_params['Accept'] = self.api_client.\ 3478 select_header_accept(['image/png']) 3479 3480 # Authentication setting 3481 auth_settings = [] 3482 3483 return self.api_client.call_api(resource_path, 'GET', 3484 path_params, 3485 query_params, 3486 header_params, 3487 body=body_params, 3488 post_params=form_params, 3489 files=local_var_files, 3490 response_type='file', 3491 auth_settings=auth_settings, 3492 callback=params.get('callback'), 3493 _return_http_data_only=params.get('_return_http_data_only'), 3494 _preload_content=params.get('_preload_content', True), 3495 _request_timeout=params.get('_request_timeout'), 3496 collection_formats=collection_formats) 3497 3498 def get_brand_resources(self, account_id, brand_id, **kwargs): 3499 """ 3500 Returns the specified account's list of branding resources (metadata). 3501 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**). 3502 This method makes a synchronous HTTP request by default. To make an 3503 asynchronous HTTP request, please define a `callback` function 3504 to be invoked when receiving the response. 3505 >>> def callback_function(response): 3506 >>> pprint(response) 3507 >>> 3508 >>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function) 3509 3510 :param callback function: The callback function 3511 for asynchronous request. (optional) 3512 :param str account_id: The external account number (int) or account ID Guid. (required) 3513 :param str brand_id: The unique identifier of a brand. (required) 3514 :return: BrandResourcesList 3515 If the method is called asynchronously, 3516 returns the request thread. 3517 """ 3518 kwargs['_return_http_data_only'] = True 3519 if kwargs.get('callback'): 3520 return self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3521 else: 3522 (data) = self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3523 return data 3524 3525 def get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs): 3526 """ 3527 Returns the specified account's list of branding resources (metadata). 3528 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**). 3529 This method makes a synchronous HTTP request by default. To make an 3530 asynchronous HTTP request, please define a `callback` function 3531 to be invoked when receiving the response. 3532 >>> def callback_function(response): 3533 >>> pprint(response) 3534 >>> 3535 >>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function) 3536 3537 :param callback function: The callback function 3538 for asynchronous request. (optional) 3539 :param str account_id: The external account number (int) or account ID Guid. (required) 3540 :param str brand_id: The unique identifier of a brand. (required) 3541 :return: BrandResourcesList 3542 If the method is called asynchronously, 3543 returns the request thread. 3544 """ 3545 3546 all_params = ['account_id', 'brand_id'] 3547 all_params.append('callback') 3548 all_params.append('_return_http_data_only') 3549 all_params.append('_preload_content') 3550 all_params.append('_request_timeout') 3551 3552 params = locals() 3553 for key, val in iteritems(params['kwargs']): 3554 if key not in all_params: 3555 raise TypeError( 3556 "Got an unexpected keyword argument '%s'" 3557 " to method get_brand_resources" % key 3558 ) 3559 params[key] = val 3560 del params['kwargs'] 3561 # verify the required parameter 'account_id' is set 3562 if ('account_id' not in params) or (params['account_id'] is None): 3563 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources`") 3564 # verify the required parameter 'brand_id' is set 3565 if ('brand_id' not in params) or (params['brand_id'] is None): 3566 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources`") 3567 3568 3569 collection_formats = {} 3570 3571 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources'.replace('{format}', 'json') 3572 path_params = {} 3573 if 'account_id' in params: 3574 path_params['accountId'] = params['account_id'] 3575 if 'brand_id' in params: 3576 path_params['brandId'] = params['brand_id'] 3577 3578 query_params = {} 3579 3580 header_params = {} 3581 3582 form_params = [] 3583 local_var_files = {} 3584 3585 body_params = None 3586 # HTTP header `Accept` 3587 header_params['Accept'] = self.api_client.\ 3588 select_header_accept(['application/json']) 3589 3590 # Authentication setting 3591 auth_settings = [] 3592 3593 return self.api_client.call_api(resource_path, 'GET', 3594 path_params, 3595 query_params, 3596 header_params, 3597 body=body_params, 3598 post_params=form_params, 3599 files=local_var_files, 3600 response_type='BrandResourcesList', 3601 auth_settings=auth_settings, 3602 callback=params.get('callback'), 3603 _return_http_data_only=params.get('_return_http_data_only'), 3604 _preload_content=params.get('_preload_content', True), 3605 _request_timeout=params.get('_request_timeout'), 3606 collection_formats=collection_formats) 3607 3608 def get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs): 3609 """ 3610 Returns the specified branding resource file. 3611 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**). 3612 This method makes a synchronous HTTP request by default. To make an 3613 asynchronous HTTP request, please define a `callback` function 3614 to be invoked when receiving the response. 3615 >>> def callback_function(response): 3616 >>> pprint(response) 3617 >>> 3618 >>> thread = api.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, callback=callback_function) 3619 3620 :param callback function: The callback function 3621 for asynchronous request. (optional) 3622 :param str account_id: The external account number (int) or account ID Guid. (required) 3623 :param str brand_id: The unique identifier of a brand. (required) 3624 :param str resource_content_type: (required) 3625 :param str langcode: 3626 :param str return_master: 3627 :return: None 3628 If the method is called asynchronously, 3629 returns the request thread. 3630 """ 3631 kwargs['_return_http_data_only'] = True 3632 if kwargs.get('callback'): 3633 return self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3634 else: 3635 (data) = self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3636 return data 3637 3638 def get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs): 3639 """ 3640 Returns the specified branding resource file. 3641 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**). 3642 This method makes a synchronous HTTP request by default. To make an 3643 asynchronous HTTP request, please define a `callback` function 3644 to be invoked when receiving the response. 3645 >>> def callback_function(response): 3646 >>> pprint(response) 3647 >>> 3648 >>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function) 3649 3650 :param callback function: The callback function 3651 for asynchronous request. (optional) 3652 :param str account_id: The external account number (int) or account ID Guid. (required) 3653 :param str brand_id: The unique identifier of a brand. (required) 3654 :param str resource_content_type: (required) 3655 :param str langcode: 3656 :param str return_master: 3657 :return: None 3658 If the method is called asynchronously, 3659 returns the request thread. 3660 """ 3661 3662 all_params = ['account_id', 'brand_id', 'resource_content_type', 'langcode', 'return_master'] 3663 all_params.append('callback') 3664 all_params.append('_return_http_data_only') 3665 all_params.append('_preload_content') 3666 all_params.append('_request_timeout') 3667 3668 params = locals() 3669 for key, val in iteritems(params['kwargs']): 3670 if key not in all_params: 3671 raise TypeError( 3672 "Got an unexpected keyword argument '%s'" 3673 " to method get_brand_resources_by_content_type" % key 3674 ) 3675 params[key] = val 3676 del params['kwargs'] 3677 # verify the required parameter 'account_id' is set 3678 if ('account_id' not in params) or (params['account_id'] is None): 3679 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources_by_content_type`") 3680 # verify the required parameter 'brand_id' is set 3681 if ('brand_id' not in params) or (params['brand_id'] is None): 3682 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources_by_content_type`") 3683 # verify the required parameter 'resource_content_type' is set 3684 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 3685 raise ValueError("Missing the required parameter `resource_content_type` when calling `get_brand_resources_by_content_type`") 3686 3687 3688 collection_formats = {} 3689 3690 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 3691 path_params = {} 3692 if 'account_id' in params: 3693 path_params['accountId'] = params['account_id'] 3694 if 'brand_id' in params: 3695 path_params['brandId'] = params['brand_id'] 3696 if 'resource_content_type' in params: 3697 path_params['resourceContentType'] = params['resource_content_type'] 3698 3699 query_params = {} 3700 if 'langcode' in params: 3701 query_params['langcode'] = params['langcode'] 3702 if 'return_master' in params: 3703 query_params['return_master'] = params['return_master'] 3704 3705 header_params = {} 3706 3707 form_params = [] 3708 local_var_files = {} 3709 3710 body_params = None 3711 # HTTP header `Accept` 3712 header_params['Accept'] = self.api_client.\ 3713 select_header_accept(['application/json']) 3714 3715 # Authentication setting 3716 auth_settings = [] 3717 3718 return self.api_client.call_api(resource_path, 'GET', 3719 path_params, 3720 query_params, 3721 header_params, 3722 body=body_params, 3723 post_params=form_params, 3724 files=local_var_files, 3725 response_type=None, 3726 auth_settings=auth_settings, 3727 callback=params.get('callback'), 3728 _return_http_data_only=params.get('_return_http_data_only'), 3729 _preload_content=params.get('_preload_content', True), 3730 _request_timeout=params.get('_request_timeout'), 3731 collection_formats=collection_formats) 3732 3733 def get_consumer_disclosure(self, account_id, lang_code, **kwargs): 3734 """ 3735 Gets the Electronic Record and Signature Disclosure. 3736 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. 3737 This method makes a synchronous HTTP request by default. To make an 3738 asynchronous HTTP request, please define a `callback` function 3739 to be invoked when receiving the response. 3740 >>> def callback_function(response): 3741 >>> pprint(response) 3742 >>> 3743 >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function) 3744 3745 :param callback function: The callback function 3746 for asynchronous request. (optional) 3747 :param str account_id: The external account number (int) or account ID Guid. (required) 3748 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3749 :return: ConsumerDisclosure 3750 If the method is called asynchronously, 3751 returns the request thread. 3752 """ 3753 kwargs['_return_http_data_only'] = True 3754 if kwargs.get('callback'): 3755 return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3756 else: 3757 (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3758 return data 3759 3760 def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 3761 """ 3762 Gets the Electronic Record and Signature Disclosure. 3763 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. 3764 This method makes a synchronous HTTP request by default. To make an 3765 asynchronous HTTP request, please define a `callback` function 3766 to be invoked when receiving the response. 3767 >>> def callback_function(response): 3768 >>> pprint(response) 3769 >>> 3770 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 3771 3772 :param callback function: The callback function 3773 for asynchronous request. (optional) 3774 :param str account_id: The external account number (int) or account ID Guid. (required) 3775 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3776 :return: ConsumerDisclosure 3777 If the method is called asynchronously, 3778 returns the request thread. 3779 """ 3780 3781 all_params = ['account_id', 'lang_code'] 3782 all_params.append('callback') 3783 all_params.append('_return_http_data_only') 3784 all_params.append('_preload_content') 3785 all_params.append('_request_timeout') 3786 3787 params = locals() 3788 for key, val in iteritems(params['kwargs']): 3789 if key not in all_params: 3790 raise TypeError( 3791 "Got an unexpected keyword argument '%s'" 3792 " to method get_consumer_disclosure" % key 3793 ) 3794 params[key] = val 3795 del params['kwargs'] 3796 # verify the required parameter 'account_id' is set 3797 if ('account_id' not in params) or (params['account_id'] is None): 3798 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 3799 # verify the required parameter 'lang_code' is set 3800 if ('lang_code' not in params) or (params['lang_code'] is None): 3801 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 3802 3803 3804 collection_formats = {} 3805 3806 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 3807 path_params = {} 3808 if 'account_id' in params: 3809 path_params['accountId'] = params['account_id'] 3810 if 'lang_code' in params: 3811 path_params['langCode'] = params['lang_code'] 3812 3813 query_params = {} 3814 3815 header_params = {} 3816 3817 form_params = [] 3818 local_var_files = {} 3819 3820 body_params = None 3821 # HTTP header `Accept` 3822 header_params['Accept'] = self.api_client.\ 3823 select_header_accept(['application/json']) 3824 3825 # Authentication setting 3826 auth_settings = [] 3827 3828 return self.api_client.call_api(resource_path, 'GET', 3829 path_params, 3830 query_params, 3831 header_params, 3832 body=body_params, 3833 post_params=form_params, 3834 files=local_var_files, 3835 response_type='ConsumerDisclosure', 3836 auth_settings=auth_settings, 3837 callback=params.get('callback'), 3838 _return_http_data_only=params.get('_return_http_data_only'), 3839 _preload_content=params.get('_preload_content', True), 3840 _request_timeout=params.get('_request_timeout'), 3841 collection_formats=collection_formats) 3842 3843 def get_consumer_disclosure_default(self, account_id, **kwargs): 3844 """ 3845 Gets the Electronic Record and Signature Disclosure for the account. 3846 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. 3847 This method makes a synchronous HTTP request by default. To make an 3848 asynchronous HTTP request, please define a `callback` function 3849 to be invoked when receiving the response. 3850 >>> def callback_function(response): 3851 >>> pprint(response) 3852 >>> 3853 >>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function) 3854 3855 :param callback function: The callback function 3856 for asynchronous request. (optional) 3857 :param str account_id: The external account number (int) or account ID Guid. (required) 3858 :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. 3859 :return: ConsumerDisclosure 3860 If the method is called asynchronously, 3861 returns the request thread. 3862 """ 3863 kwargs['_return_http_data_only'] = True 3864 if kwargs.get('callback'): 3865 return self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3866 else: 3867 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3868 return data 3869 3870 def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs): 3871 """ 3872 Gets the Electronic Record and Signature Disclosure for the account. 3873 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. 3874 This method makes a synchronous HTTP request by default. To make an 3875 asynchronous HTTP request, please define a `callback` function 3876 to be invoked when receiving the response. 3877 >>> def callback_function(response): 3878 >>> pprint(response) 3879 >>> 3880 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function) 3881 3882 :param callback function: The callback function 3883 for asynchronous request. (optional) 3884 :param str account_id: The external account number (int) or account ID Guid. (required) 3885 :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. 3886 :return: ConsumerDisclosure 3887 If the method is called asynchronously, 3888 returns the request thread. 3889 """ 3890 3891 all_params = ['account_id', 'lang_code'] 3892 all_params.append('callback') 3893 all_params.append('_return_http_data_only') 3894 all_params.append('_preload_content') 3895 all_params.append('_request_timeout') 3896 3897 params = locals() 3898 for key, val in iteritems(params['kwargs']): 3899 if key not in all_params: 3900 raise TypeError( 3901 "Got an unexpected keyword argument '%s'" 3902 " to method get_consumer_disclosure_default" % key 3903 ) 3904 params[key] = val 3905 del params['kwargs'] 3906 # verify the required parameter 'account_id' is set 3907 if ('account_id' not in params) or (params['account_id'] is None): 3908 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 3909 3910 3911 collection_formats = {} 3912 3913 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json') 3914 path_params = {} 3915 if 'account_id' in params: 3916 path_params['accountId'] = params['account_id'] 3917 3918 query_params = {} 3919 if 'lang_code' in params: 3920 query_params['langCode'] = params['lang_code'] 3921 3922 header_params = {} 3923 3924 form_params = [] 3925 local_var_files = {} 3926 3927 body_params = None 3928 # HTTP header `Accept` 3929 header_params['Accept'] = self.api_client.\ 3930 select_header_accept(['application/json']) 3931 3932 # Authentication setting 3933 auth_settings = [] 3934 3935 return self.api_client.call_api(resource_path, 'GET', 3936 path_params, 3937 query_params, 3938 header_params, 3939 body=body_params, 3940 post_params=form_params, 3941 files=local_var_files, 3942 response_type='ConsumerDisclosure', 3943 auth_settings=auth_settings, 3944 callback=params.get('callback'), 3945 _return_http_data_only=params.get('_return_http_data_only'), 3946 _preload_content=params.get('_preload_content', True), 3947 _request_timeout=params.get('_request_timeout'), 3948 collection_formats=collection_formats) 3949 3950 def get_e_note_configuration(self, account_id, **kwargs): 3951 """ 3952 Returns the configuration information for the eNote eOriginal integration. 3953 3954 This method makes a synchronous HTTP request by default. To make an 3955 asynchronous HTTP request, please define a `callback` function 3956 to be invoked when receiving the response. 3957 >>> def callback_function(response): 3958 >>> pprint(response) 3959 >>> 3960 >>> thread = api.get_e_note_configuration(account_id, callback=callback_function) 3961 3962 :param callback function: The callback function 3963 for asynchronous request. (optional) 3964 :param str account_id: The external account number (int) or account ID Guid. (required) 3965 :return: ENoteConfiguration 3966 If the method is called asynchronously, 3967 returns the request thread. 3968 """ 3969 kwargs['_return_http_data_only'] = True 3970 if kwargs.get('callback'): 3971 return self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3972 else: 3973 (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3974 return data 3975 3976 def get_e_note_configuration_with_http_info(self, account_id, **kwargs): 3977 """ 3978 Returns the configuration information for the eNote eOriginal integration. 3979 3980 This method makes a synchronous HTTP request by default. To make an 3981 asynchronous HTTP request, please define a `callback` function 3982 to be invoked when receiving the response. 3983 >>> def callback_function(response): 3984 >>> pprint(response) 3985 >>> 3986 >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function) 3987 3988 :param callback function: The callback function 3989 for asynchronous request. (optional) 3990 :param str account_id: The external account number (int) or account ID Guid. (required) 3991 :return: ENoteConfiguration 3992 If the method is called asynchronously, 3993 returns the request thread. 3994 """ 3995 3996 all_params = ['account_id'] 3997 all_params.append('callback') 3998 all_params.append('_return_http_data_only') 3999 all_params.append('_preload_content') 4000 all_params.append('_request_timeout') 4001 4002 params = locals() 4003 for key, val in iteritems(params['kwargs']): 4004 if key not in all_params: 4005 raise TypeError( 4006 "Got an unexpected keyword argument '%s'" 4007 " to method get_e_note_configuration" % key 4008 ) 4009 params[key] = val 4010 del params['kwargs'] 4011 # verify the required parameter 'account_id' is set 4012 if ('account_id' not in params) or (params['account_id'] is None): 4013 raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`") 4014 4015 4016 collection_formats = {} 4017 4018 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 4019 path_params = {} 4020 if 'account_id' in params: 4021 path_params['accountId'] = params['account_id'] 4022 4023 query_params = {} 4024 4025 header_params = {} 4026 4027 form_params = [] 4028 local_var_files = {} 4029 4030 body_params = None 4031 # HTTP header `Accept` 4032 header_params['Accept'] = self.api_client.\ 4033 select_header_accept(['application/json']) 4034 4035 # Authentication setting 4036 auth_settings = [] 4037 4038 return self.api_client.call_api(resource_path, 'GET', 4039 path_params, 4040 query_params, 4041 header_params, 4042 body=body_params, 4043 post_params=form_params, 4044 files=local_var_files, 4045 response_type='ENoteConfiguration', 4046 auth_settings=auth_settings, 4047 callback=params.get('callback'), 4048 _return_http_data_only=params.get('_return_http_data_only'), 4049 _preload_content=params.get('_preload_content', True), 4050 _request_timeout=params.get('_request_timeout'), 4051 collection_formats=collection_formats) 4052 4053 def get_envelope_purge_configuration(self, account_id, **kwargs): 4054 """ 4055 Select envelope purge configuration. 4056 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. 4057 This method makes a synchronous HTTP request by default. To make an 4058 asynchronous HTTP request, please define a `callback` function 4059 to be invoked when receiving the response. 4060 >>> def callback_function(response): 4061 >>> pprint(response) 4062 >>> 4063 >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function) 4064 4065 :param callback function: The callback function 4066 for asynchronous request. (optional) 4067 :param str account_id: The external account number (int) or account ID Guid. (required) 4068 :return: EnvelopePurgeConfiguration 4069 If the method is called asynchronously, 4070 returns the request thread. 4071 """ 4072 kwargs['_return_http_data_only'] = True 4073 if kwargs.get('callback'): 4074 return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4075 else: 4076 (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4077 return data 4078 4079 def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 4080 """ 4081 Select envelope purge configuration. 4082 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. 4083 This method makes a synchronous HTTP request by default. To make an 4084 asynchronous HTTP request, please define a `callback` function 4085 to be invoked when receiving the response. 4086 >>> def callback_function(response): 4087 >>> pprint(response) 4088 >>> 4089 >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 4090 4091 :param callback function: The callback function 4092 for asynchronous request. (optional) 4093 :param str account_id: The external account number (int) or account ID Guid. (required) 4094 :return: EnvelopePurgeConfiguration 4095 If the method is called asynchronously, 4096 returns the request thread. 4097 """ 4098 4099 all_params = ['account_id'] 4100 all_params.append('callback') 4101 all_params.append('_return_http_data_only') 4102 all_params.append('_preload_content') 4103 all_params.append('_request_timeout') 4104 4105 params = locals() 4106 for key, val in iteritems(params['kwargs']): 4107 if key not in all_params: 4108 raise TypeError( 4109 "Got an unexpected keyword argument '%s'" 4110 " to method get_envelope_purge_configuration" % key 4111 ) 4112 params[key] = val 4113 del params['kwargs'] 4114 # verify the required parameter 'account_id' is set 4115 if ('account_id' not in params) or (params['account_id'] is None): 4116 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`") 4117 4118 4119 collection_formats = {} 4120 4121 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 4122 path_params = {} 4123 if 'account_id' in params: 4124 path_params['accountId'] = params['account_id'] 4125 4126 query_params = {} 4127 4128 header_params = {} 4129 4130 form_params = [] 4131 local_var_files = {} 4132 4133 body_params = None 4134 # HTTP header `Accept` 4135 header_params['Accept'] = self.api_client.\ 4136 select_header_accept(['application/json']) 4137 4138 # Authentication setting 4139 auth_settings = [] 4140 4141 return self.api_client.call_api(resource_path, 'GET', 4142 path_params, 4143 query_params, 4144 header_params, 4145 body=body_params, 4146 post_params=form_params, 4147 files=local_var_files, 4148 response_type='EnvelopePurgeConfiguration', 4149 auth_settings=auth_settings, 4150 callback=params.get('callback'), 4151 _return_http_data_only=params.get('_return_http_data_only'), 4152 _preload_content=params.get('_preload_content', True), 4153 _request_timeout=params.get('_request_timeout'), 4154 collection_formats=collection_formats) 4155 4156 def get_favorite_templates(self, account_id, **kwargs): 4157 """ 4158 Retrieves the list of favorited templates for this caller 4159 4160 This method makes a synchronous HTTP request by default. To make an 4161 asynchronous HTTP request, please define a `callback` function 4162 to be invoked when receiving the response. 4163 >>> def callback_function(response): 4164 >>> pprint(response) 4165 >>> 4166 >>> thread = api.get_favorite_templates(account_id, callback=callback_function) 4167 4168 :param callback function: The callback function 4169 for asynchronous request. (optional) 4170 :param str account_id: The external account number (int) or account ID Guid. (required) 4171 :return: FavoriteTemplatesInfo 4172 If the method is called asynchronously, 4173 returns the request thread. 4174 """ 4175 kwargs['_return_http_data_only'] = True 4176 if kwargs.get('callback'): 4177 return self.get_favorite_templates_with_http_info(account_id, **kwargs) 4178 else: 4179 (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs) 4180 return data 4181 4182 def get_favorite_templates_with_http_info(self, account_id, **kwargs): 4183 """ 4184 Retrieves the list of favorited templates for this caller 4185 4186 This method makes a synchronous HTTP request by default. To make an 4187 asynchronous HTTP request, please define a `callback` function 4188 to be invoked when receiving the response. 4189 >>> def callback_function(response): 4190 >>> pprint(response) 4191 >>> 4192 >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function) 4193 4194 :param callback function: The callback function 4195 for asynchronous request. (optional) 4196 :param str account_id: The external account number (int) or account ID Guid. (required) 4197 :return: FavoriteTemplatesInfo 4198 If the method is called asynchronously, 4199 returns the request thread. 4200 """ 4201 4202 all_params = ['account_id'] 4203 all_params.append('callback') 4204 all_params.append('_return_http_data_only') 4205 all_params.append('_preload_content') 4206 all_params.append('_request_timeout') 4207 4208 params = locals() 4209 for key, val in iteritems(params['kwargs']): 4210 if key not in all_params: 4211 raise TypeError( 4212 "Got an unexpected keyword argument '%s'" 4213 " to method get_favorite_templates" % key 4214 ) 4215 params[key] = val 4216 del params['kwargs'] 4217 # verify the required parameter 'account_id' is set 4218 if ('account_id' not in params) or (params['account_id'] is None): 4219 raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`") 4220 4221 4222 collection_formats = {} 4223 4224 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 4225 path_params = {} 4226 if 'account_id' in params: 4227 path_params['accountId'] = params['account_id'] 4228 4229 query_params = {} 4230 4231 header_params = {} 4232 4233 form_params = [] 4234 local_var_files = {} 4235 4236 body_params = None 4237 # HTTP header `Accept` 4238 header_params['Accept'] = self.api_client.\ 4239 select_header_accept(['application/json']) 4240 4241 # Authentication setting 4242 auth_settings = [] 4243 4244 return self.api_client.call_api(resource_path, 'GET', 4245 path_params, 4246 query_params, 4247 header_params, 4248 body=body_params, 4249 post_params=form_params, 4250 files=local_var_files, 4251 response_type='FavoriteTemplatesInfo', 4252 auth_settings=auth_settings, 4253 callback=params.get('callback'), 4254 _return_http_data_only=params.get('_return_http_data_only'), 4255 _preload_content=params.get('_preload_content', True), 4256 _request_timeout=params.get('_request_timeout'), 4257 collection_formats=collection_formats) 4258 4259 def get_notification_defaults(self, account_id, **kwargs): 4260 """ 4261 Returns default user level settings for a specified account 4262 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4263 This method makes a synchronous HTTP request by default. To make an 4264 asynchronous HTTP request, please define a `callback` function 4265 to be invoked when receiving the response. 4266 >>> def callback_function(response): 4267 >>> pprint(response) 4268 >>> 4269 >>> thread = api.get_notification_defaults(account_id, callback=callback_function) 4270 4271 :param callback function: The callback function 4272 for asynchronous request. (optional) 4273 :param str account_id: The external account number (int) or account ID Guid. (required) 4274 :return: NotificationDefaults 4275 If the method is called asynchronously, 4276 returns the request thread. 4277 """ 4278 kwargs['_return_http_data_only'] = True 4279 if kwargs.get('callback'): 4280 return self.get_notification_defaults_with_http_info(account_id, **kwargs) 4281 else: 4282 (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs) 4283 return data 4284 4285 def get_notification_defaults_with_http_info(self, account_id, **kwargs): 4286 """ 4287 Returns default user level settings for a specified account 4288 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4289 This method makes a synchronous HTTP request by default. To make an 4290 asynchronous HTTP request, please define a `callback` function 4291 to be invoked when receiving the response. 4292 >>> def callback_function(response): 4293 >>> pprint(response) 4294 >>> 4295 >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function) 4296 4297 :param callback function: The callback function 4298 for asynchronous request. (optional) 4299 :param str account_id: The external account number (int) or account ID Guid. (required) 4300 :return: NotificationDefaults 4301 If the method is called asynchronously, 4302 returns the request thread. 4303 """ 4304 4305 all_params = ['account_id'] 4306 all_params.append('callback') 4307 all_params.append('_return_http_data_only') 4308 all_params.append('_preload_content') 4309 all_params.append('_request_timeout') 4310 4311 params = locals() 4312 for key, val in iteritems(params['kwargs']): 4313 if key not in all_params: 4314 raise TypeError( 4315 "Got an unexpected keyword argument '%s'" 4316 " to method get_notification_defaults" % key 4317 ) 4318 params[key] = val 4319 del params['kwargs'] 4320 # verify the required parameter 'account_id' is set 4321 if ('account_id' not in params) or (params['account_id'] is None): 4322 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`") 4323 4324 4325 collection_formats = {} 4326 4327 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 4328 path_params = {} 4329 if 'account_id' in params: 4330 path_params['accountId'] = params['account_id'] 4331 4332 query_params = {} 4333 4334 header_params = {} 4335 4336 form_params = [] 4337 local_var_files = {} 4338 4339 body_params = None 4340 # HTTP header `Accept` 4341 header_params['Accept'] = self.api_client.\ 4342 select_header_accept(['application/json']) 4343 4344 # Authentication setting 4345 auth_settings = [] 4346 4347 return self.api_client.call_api(resource_path, 'GET', 4348 path_params, 4349 query_params, 4350 header_params, 4351 body=body_params, 4352 post_params=form_params, 4353 files=local_var_files, 4354 response_type='NotificationDefaults', 4355 auth_settings=auth_settings, 4356 callback=params.get('callback'), 4357 _return_http_data_only=params.get('_return_http_data_only'), 4358 _preload_content=params.get('_preload_content', True), 4359 _request_timeout=params.get('_request_timeout'), 4360 collection_formats=collection_formats) 4361 4362 def get_password_rules(self, account_id, **kwargs): 4363 """ 4364 Get the password rules 4365 This method retrieves the password rules for an account. 4366 This method makes a synchronous HTTP request by default. To make an 4367 asynchronous HTTP request, please define a `callback` function 4368 to be invoked when receiving the response. 4369 >>> def callback_function(response): 4370 >>> pprint(response) 4371 >>> 4372 >>> thread = api.get_password_rules(account_id, callback=callback_function) 4373 4374 :param callback function: The callback function 4375 for asynchronous request. (optional) 4376 :param str account_id: The external account number (int) or account ID Guid. (required) 4377 :return: AccountPasswordRules 4378 If the method is called asynchronously, 4379 returns the request thread. 4380 """ 4381 kwargs['_return_http_data_only'] = True 4382 if kwargs.get('callback'): 4383 return self.get_password_rules_with_http_info(account_id, **kwargs) 4384 else: 4385 (data) = self.get_password_rules_with_http_info(account_id, **kwargs) 4386 return data 4387 4388 def get_password_rules_with_http_info(self, account_id, **kwargs): 4389 """ 4390 Get the password rules 4391 This method retrieves the password rules for an account. 4392 This method makes a synchronous HTTP request by default. To make an 4393 asynchronous HTTP request, please define a `callback` function 4394 to be invoked when receiving the response. 4395 >>> def callback_function(response): 4396 >>> pprint(response) 4397 >>> 4398 >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function) 4399 4400 :param callback function: The callback function 4401 for asynchronous request. (optional) 4402 :param str account_id: The external account number (int) or account ID Guid. (required) 4403 :return: AccountPasswordRules 4404 If the method is called asynchronously, 4405 returns the request thread. 4406 """ 4407 4408 all_params = ['account_id'] 4409 all_params.append('callback') 4410 all_params.append('_return_http_data_only') 4411 all_params.append('_preload_content') 4412 all_params.append('_request_timeout') 4413 4414 params = locals() 4415 for key, val in iteritems(params['kwargs']): 4416 if key not in all_params: 4417 raise TypeError( 4418 "Got an unexpected keyword argument '%s'" 4419 " to method get_password_rules" % key 4420 ) 4421 params[key] = val 4422 del params['kwargs'] 4423 # verify the required parameter 'account_id' is set 4424 if ('account_id' not in params) or (params['account_id'] is None): 4425 raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`") 4426 4427 4428 collection_formats = {} 4429 4430 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 4431 path_params = {} 4432 if 'account_id' in params: 4433 path_params['accountId'] = params['account_id'] 4434 4435 query_params = {} 4436 4437 header_params = {} 4438 4439 form_params = [] 4440 local_var_files = {} 4441 4442 body_params = None 4443 # HTTP header `Accept` 4444 header_params['Accept'] = self.api_client.\ 4445 select_header_accept(['application/json']) 4446 4447 # Authentication setting 4448 auth_settings = [] 4449 4450 return self.api_client.call_api(resource_path, 'GET', 4451 path_params, 4452 query_params, 4453 header_params, 4454 body=body_params, 4455 post_params=form_params, 4456 files=local_var_files, 4457 response_type='AccountPasswordRules', 4458 auth_settings=auth_settings, 4459 callback=params.get('callback'), 4460 _return_http_data_only=params.get('_return_http_data_only'), 4461 _preload_content=params.get('_preload_content', True), 4462 _request_timeout=params.get('_request_timeout'), 4463 collection_formats=collection_formats) 4464 4465 def get_password_rules_0(self, **kwargs): 4466 """ 4467 Get membership account password rules 4468 4469 This method makes a synchronous HTTP request by default. To make an 4470 asynchronous HTTP request, please define a `callback` function 4471 to be invoked when receiving the response. 4472 >>> def callback_function(response): 4473 >>> pprint(response) 4474 >>> 4475 >>> thread = api.get_password_rules_0(callback=callback_function) 4476 4477 :param callback function: The callback function 4478 for asynchronous request. (optional) 4479 :return: UserPasswordRules 4480 If the method is called asynchronously, 4481 returns the request thread. 4482 """ 4483 kwargs['_return_http_data_only'] = True 4484 if kwargs.get('callback'): 4485 return self.get_password_rules_0_with_http_info(**kwargs) 4486 else: 4487 (data) = self.get_password_rules_0_with_http_info(**kwargs) 4488 return data 4489 4490 def get_password_rules_0_with_http_info(self, **kwargs): 4491 """ 4492 Get membership account password rules 4493 4494 This method makes a synchronous HTTP request by default. To make an 4495 asynchronous HTTP request, please define a `callback` function 4496 to be invoked when receiving the response. 4497 >>> def callback_function(response): 4498 >>> pprint(response) 4499 >>> 4500 >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function) 4501 4502 :param callback function: The callback function 4503 for asynchronous request. (optional) 4504 :return: UserPasswordRules 4505 If the method is called asynchronously, 4506 returns the request thread. 4507 """ 4508 4509 all_params = [] 4510 all_params.append('callback') 4511 all_params.append('_return_http_data_only') 4512 all_params.append('_preload_content') 4513 all_params.append('_request_timeout') 4514 4515 params = locals() 4516 for key, val in iteritems(params['kwargs']): 4517 if key not in all_params: 4518 raise TypeError( 4519 "Got an unexpected keyword argument '%s'" 4520 " to method get_password_rules_0" % key 4521 ) 4522 params[key] = val 4523 del params['kwargs'] 4524 4525 collection_formats = {} 4526 4527 resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json') 4528 path_params = {} 4529 4530 query_params = {} 4531 4532 header_params = {} 4533 4534 form_params = [] 4535 local_var_files = {} 4536 4537 body_params = None 4538 # HTTP header `Accept` 4539 header_params['Accept'] = self.api_client.\ 4540 select_header_accept(['application/json']) 4541 4542 # Authentication setting 4543 auth_settings = [] 4544 4545 return self.api_client.call_api(resource_path, 'GET', 4546 path_params, 4547 query_params, 4548 header_params, 4549 body=body_params, 4550 post_params=form_params, 4551 files=local_var_files, 4552 response_type='UserPasswordRules', 4553 auth_settings=auth_settings, 4554 callback=params.get('callback'), 4555 _return_http_data_only=params.get('_return_http_data_only'), 4556 _preload_content=params.get('_preload_content', True), 4557 _request_timeout=params.get('_request_timeout'), 4558 collection_formats=collection_formats) 4559 4560 def get_permission_profile(self, account_id, permission_profile_id, **kwargs): 4561 """ 4562 Returns a permissions profile in the specified account. 4563 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/) 4564 This method makes a synchronous HTTP request by default. To make an 4565 asynchronous HTTP request, please define a `callback` function 4566 to be invoked when receiving the response. 4567 >>> def callback_function(response): 4568 >>> pprint(response) 4569 >>> 4570 >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function) 4571 4572 :param callback function: The callback function 4573 for asynchronous request. (optional) 4574 :param str account_id: The external account number (int) or account ID Guid. (required) 4575 :param str permission_profile_id: (required) 4576 :param str include: 4577 :return: PermissionProfile 4578 If the method is called asynchronously, 4579 returns the request thread. 4580 """ 4581 kwargs['_return_http_data_only'] = True 4582 if kwargs.get('callback'): 4583 return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4584 else: 4585 (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4586 return data 4587 4588 def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 4589 """ 4590 Returns a permissions profile in the specified account. 4591 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/) 4592 This method makes a synchronous HTTP request by default. To make an 4593 asynchronous HTTP request, please define a `callback` function 4594 to be invoked when receiving the response. 4595 >>> def callback_function(response): 4596 >>> pprint(response) 4597 >>> 4598 >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 4599 4600 :param callback function: The callback function 4601 for asynchronous request. (optional) 4602 :param str account_id: The external account number (int) or account ID Guid. (required) 4603 :param str permission_profile_id: (required) 4604 :param str include: 4605 :return: PermissionProfile 4606 If the method is called asynchronously, 4607 returns the request thread. 4608 """ 4609 4610 all_params = ['account_id', 'permission_profile_id', 'include'] 4611 all_params.append('callback') 4612 all_params.append('_return_http_data_only') 4613 all_params.append('_preload_content') 4614 all_params.append('_request_timeout') 4615 4616 params = locals() 4617 for key, val in iteritems(params['kwargs']): 4618 if key not in all_params: 4619 raise TypeError( 4620 "Got an unexpected keyword argument '%s'" 4621 " to method get_permission_profile" % key 4622 ) 4623 params[key] = val 4624 del params['kwargs'] 4625 # verify the required parameter 'account_id' is set 4626 if ('account_id' not in params) or (params['account_id'] is None): 4627 raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`") 4628 # verify the required parameter 'permission_profile_id' is set 4629 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 4630 raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`") 4631 4632 4633 collection_formats = {} 4634 4635 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 4636 path_params = {} 4637 if 'account_id' in params: 4638 path_params['accountId'] = params['account_id'] 4639 if 'permission_profile_id' in params: 4640 path_params['permissionProfileId'] = params['permission_profile_id'] 4641 4642 query_params = {} 4643 if 'include' in params: 4644 query_params['include'] = params['include'] 4645 4646 header_params = {} 4647 4648 form_params = [] 4649 local_var_files = {} 4650 4651 body_params = None 4652 # HTTP header `Accept` 4653 header_params['Accept'] = self.api_client.\ 4654 select_header_accept(['application/json']) 4655 4656 # Authentication setting 4657 auth_settings = [] 4658 4659 return self.api_client.call_api(resource_path, 'GET', 4660 path_params, 4661 query_params, 4662 header_params, 4663 body=body_params, 4664 post_params=form_params, 4665 files=local_var_files, 4666 response_type='PermissionProfile', 4667 auth_settings=auth_settings, 4668 callback=params.get('callback'), 4669 _return_http_data_only=params.get('_return_http_data_only'), 4670 _preload_content=params.get('_preload_content', True), 4671 _request_timeout=params.get('_request_timeout'), 4672 collection_formats=collection_formats) 4673 4674 def get_principal_user_authorizations(self, account_id, user_id, **kwargs): 4675 """ 4676 Returns the principal user authorizations 4677 This method makes a synchronous HTTP request by default. To make an 4678 asynchronous HTTP request, please define a `callback` function 4679 to be invoked when receiving the response. 4680 >>> def callback_function(response): 4681 >>> pprint(response) 4682 >>> 4683 >>> thread = api.get_principal_user_authorizations(account_id, user_id, callback=callback_function) 4684 4685 :param callback function: The callback function 4686 for asynchronous request. (optional) 4687 :param str account_id: The external account number (int) or account ID Guid. (required) 4688 :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) 4689 :param str active_only: 4690 :param str count: 4691 :param str email_substring: Part (substring) of email we are searching for. 4692 :param str include_closed_users: 4693 :param str permissions: 4694 :param str start_position: 4695 :param str user_name_substring: 4696 :return: UserAuthorizations 4697 If the method is called asynchronously, 4698 returns the request thread. 4699 """ 4700 kwargs['_return_http_data_only'] = True 4701 if kwargs.get('callback'): 4702 return self.get_principal_user_authorizations_with_http_info(account_id, user_id, **kwargs) 4703 else: 4704 (data) = self.get_principal_user_authorizations_with_http_info(account_id, user_id, **kwargs) 4705 return data 4706 4707 def get_principal_user_authorizations_with_http_info(self, account_id, user_id, **kwargs): 4708 """ 4709 Returns the principal user authorizations 4710 This method makes a synchronous HTTP request by default. To make an 4711 asynchronous HTTP request, please define a `callback` function 4712 to be invoked when receiving the response. 4713 >>> def callback_function(response): 4714 >>> pprint(response) 4715 >>> 4716 >>> thread = api.get_principal_user_authorizations_with_http_info(account_id, user_id, callback=callback_function) 4717 4718 :param callback function: The callback function 4719 for asynchronous request. (optional) 4720 :param str account_id: The external account number (int) or account ID Guid. (required) 4721 :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) 4722 :param str active_only: 4723 :param str count: 4724 :param str email_substring: Part (substring) of email we are searching for. 4725 :param str include_closed_users: 4726 :param str permissions: 4727 :param str start_position: 4728 :param str user_name_substring: 4729 :return: UserAuthorizations 4730 If the method is called asynchronously, 4731 returns the request thread. 4732 """ 4733 4734 all_params = ['account_id', 'user_id', 'active_only', 'count', 'email_substring', 'include_closed_users', 'permissions', 'start_position', 'user_name_substring'] 4735 all_params.append('callback') 4736 all_params.append('_return_http_data_only') 4737 all_params.append('_preload_content') 4738 all_params.append('_request_timeout') 4739 4740 params = locals() 4741 for key, val in iteritems(params['kwargs']): 4742 if key not in all_params: 4743 raise TypeError( 4744 "Got an unexpected keyword argument '%s'" 4745 " to method get_principal_user_authorizations" % key 4746 ) 4747 params[key] = val 4748 del params['kwargs'] 4749 # verify the required parameter 'account_id' is set 4750 if ('account_id' not in params) or (params['account_id'] is None): 4751 raise ValueError("Missing the required parameter `account_id` when calling `get_principal_user_authorizations`") 4752 # verify the required parameter 'user_id' is set 4753 if ('user_id' not in params) or (params['user_id'] is None): 4754 raise ValueError("Missing the required parameter `user_id` when calling `get_principal_user_authorizations`") 4755 4756 4757 collection_formats = {} 4758 4759 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorizations'.replace('{format}', 'json') 4760 path_params = {} 4761 if 'account_id' in params: 4762 path_params['accountId'] = params['account_id'] 4763 if 'user_id' in params: 4764 path_params['userId'] = params['user_id'] 4765 4766 query_params = {} 4767 if 'active_only' in params: 4768 query_params['active_only'] = params['active_only'] 4769 if 'count' in params: 4770 query_params['count'] = params['count'] 4771 if 'email_substring' in params: 4772 query_params['email_substring'] = params['email_substring'] 4773 if 'include_closed_users' in params: 4774 query_params['include_closed_users'] = params['include_closed_users'] 4775 if 'permissions' in params: 4776 query_params['permissions'] = params['permissions'] 4777 if 'start_position' in params: 4778 query_params['start_position'] = params['start_position'] 4779 if 'user_name_substring' in params: 4780 query_params['user_name_substring'] = params['user_name_substring'] 4781 4782 header_params = {} 4783 4784 form_params = [] 4785 local_var_files = {} 4786 4787 body_params = None 4788 # HTTP header `Accept` 4789 header_params['Accept'] = self.api_client.\ 4790 select_header_accept(['application/json']) 4791 4792 # Authentication setting 4793 auth_settings = [] 4794 4795 return self.api_client.call_api(resource_path, 'GET', 4796 path_params, 4797 query_params, 4798 header_params, 4799 body=body_params, 4800 post_params=form_params, 4801 files=local_var_files, 4802 response_type='UserAuthorizations', 4803 auth_settings=auth_settings, 4804 callback=params.get('callback'), 4805 _return_http_data_only=params.get('_return_http_data_only'), 4806 _preload_content=params.get('_preload_content', True), 4807 _request_timeout=params.get('_request_timeout'), 4808 collection_formats=collection_formats) 4809 4810 def get_provisioning(self, **kwargs): 4811 """ 4812 Retrieves the account provisioning information for the account. 4813 Retrieves the account provisioning information for the account. 4814 This method makes a synchronous HTTP request by default. To make an 4815 asynchronous HTTP request, please define a `callback` function 4816 to be invoked when receiving the response. 4817 >>> def callback_function(response): 4818 >>> pprint(response) 4819 >>> 4820 >>> thread = api.get_provisioning(callback=callback_function) 4821 4822 :param callback function: The callback function 4823 for asynchronous request. (optional) 4824 :return: ProvisioningInformation 4825 If the method is called asynchronously, 4826 returns the request thread. 4827 """ 4828 kwargs['_return_http_data_only'] = True 4829 if kwargs.get('callback'): 4830 return self.get_provisioning_with_http_info(**kwargs) 4831 else: 4832 (data) = self.get_provisioning_with_http_info(**kwargs) 4833 return data 4834 4835 def get_provisioning_with_http_info(self, **kwargs): 4836 """ 4837 Retrieves the account provisioning information for the account. 4838 Retrieves the account provisioning information for the account. 4839 This method makes a synchronous HTTP request by default. To make an 4840 asynchronous HTTP request, please define a `callback` function 4841 to be invoked when receiving the response. 4842 >>> def callback_function(response): 4843 >>> pprint(response) 4844 >>> 4845 >>> thread = api.get_provisioning_with_http_info(callback=callback_function) 4846 4847 :param callback function: The callback function 4848 for asynchronous request. (optional) 4849 :return: ProvisioningInformation 4850 If the method is called asynchronously, 4851 returns the request thread. 4852 """ 4853 4854 all_params = [] 4855 all_params.append('callback') 4856 all_params.append('_return_http_data_only') 4857 all_params.append('_preload_content') 4858 all_params.append('_request_timeout') 4859 4860 params = locals() 4861 for key, val in iteritems(params['kwargs']): 4862 if key not in all_params: 4863 raise TypeError( 4864 "Got an unexpected keyword argument '%s'" 4865 " to method get_provisioning" % key 4866 ) 4867 params[key] = val 4868 del params['kwargs'] 4869 4870 collection_formats = {} 4871 4872 resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json') 4873 path_params = {} 4874 4875 query_params = {} 4876 4877 header_params = {} 4878 4879 form_params = [] 4880 local_var_files = {} 4881 4882 body_params = None 4883 # HTTP header `Accept` 4884 header_params['Accept'] = self.api_client.\ 4885 select_header_accept(['application/json']) 4886 4887 # Authentication setting 4888 auth_settings = [] 4889 4890 return self.api_client.call_api(resource_path, 'GET', 4891 path_params, 4892 query_params, 4893 header_params, 4894 body=body_params, 4895 post_params=form_params, 4896 files=local_var_files, 4897 response_type='ProvisioningInformation', 4898 auth_settings=auth_settings, 4899 callback=params.get('callback'), 4900 _return_http_data_only=params.get('_return_http_data_only'), 4901 _preload_content=params.get('_preload_content', True), 4902 _request_timeout=params.get('_request_timeout'), 4903 collection_formats=collection_formats) 4904 4905 def get_supported_languages(self, account_id, **kwargs): 4906 """ 4907 Gets list of supported languages for recipient language setting. 4908 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). 4909 This method makes a synchronous HTTP request by default. To make an 4910 asynchronous HTTP request, please define a `callback` function 4911 to be invoked when receiving the response. 4912 >>> def callback_function(response): 4913 >>> pprint(response) 4914 >>> 4915 >>> thread = api.get_supported_languages(account_id, callback=callback_function) 4916 4917 :param callback function: The callback function 4918 for asynchronous request. (optional) 4919 :param str account_id: The external account number (int) or account ID Guid. (required) 4920 :return: SupportedLanguages 4921 If the method is called asynchronously, 4922 returns the request thread. 4923 """ 4924 kwargs['_return_http_data_only'] = True 4925 if kwargs.get('callback'): 4926 return self.get_supported_languages_with_http_info(account_id, **kwargs) 4927 else: 4928 (data) = self.get_supported_languages_with_http_info(account_id, **kwargs) 4929 return data 4930 4931 def get_supported_languages_with_http_info(self, account_id, **kwargs): 4932 """ 4933 Gets list of supported languages for recipient language setting. 4934 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). 4935 This method makes a synchronous HTTP request by default. To make an 4936 asynchronous HTTP request, please define a `callback` function 4937 to be invoked when receiving the response. 4938 >>> def callback_function(response): 4939 >>> pprint(response) 4940 >>> 4941 >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function) 4942 4943 :param callback function: The callback function 4944 for asynchronous request. (optional) 4945 :param str account_id: The external account number (int) or account ID Guid. (required) 4946 :return: SupportedLanguages 4947 If the method is called asynchronously, 4948 returns the request thread. 4949 """ 4950 4951 all_params = ['account_id'] 4952 all_params.append('callback') 4953 all_params.append('_return_http_data_only') 4954 all_params.append('_preload_content') 4955 all_params.append('_request_timeout') 4956 4957 params = locals() 4958 for key, val in iteritems(params['kwargs']): 4959 if key not in all_params: 4960 raise TypeError( 4961 "Got an unexpected keyword argument '%s'" 4962 " to method get_supported_languages" % key 4963 ) 4964 params[key] = val 4965 del params['kwargs'] 4966 # verify the required parameter 'account_id' is set 4967 if ('account_id' not in params) or (params['account_id'] is None): 4968 raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`") 4969 4970 4971 collection_formats = {} 4972 4973 resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json') 4974 path_params = {} 4975 if 'account_id' in params: 4976 path_params['accountId'] = params['account_id'] 4977 4978 query_params = {} 4979 4980 header_params = {} 4981 4982 form_params = [] 4983 local_var_files = {} 4984 4985 body_params = None 4986 # HTTP header `Accept` 4987 header_params['Accept'] = self.api_client.\ 4988 select_header_accept(['application/json']) 4989 4990 # Authentication setting 4991 auth_settings = [] 4992 4993 return self.api_client.call_api(resource_path, 'GET', 4994 path_params, 4995 query_params, 4996 header_params, 4997 body=body_params, 4998 post_params=form_params, 4999 files=local_var_files, 5000 response_type='SupportedLanguages', 5001 auth_settings=auth_settings, 5002 callback=params.get('callback'), 5003 _return_http_data_only=params.get('_return_http_data_only'), 5004 _preload_content=params.get('_preload_content', True), 5005 _request_timeout=params.get('_request_timeout'), 5006 collection_formats=collection_formats) 5007 5008 def get_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 5009 """ 5010 Returns the user authorization for a given authorization id 5011 This method makes a synchronous HTTP request by default. To make an 5012 asynchronous HTTP request, please define a `callback` function 5013 to be invoked when receiving the response. 5014 >>> def callback_function(response): 5015 >>> pprint(response) 5016 >>> 5017 >>> thread = api.get_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 5018 5019 :param callback function: The callback function 5020 for asynchronous request. (optional) 5021 :param str account_id: The external account number (int) or account ID Guid. (required) 5022 :param str authorization_id: (required) 5023 :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) 5024 :return: UserAuthorization 5025 If the method is called asynchronously, 5026 returns the request thread. 5027 """ 5028 kwargs['_return_http_data_only'] = True 5029 if kwargs.get('callback'): 5030 return self.get_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 5031 else: 5032 (data) = self.get_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 5033 return data 5034 5035 def get_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 5036 """ 5037 Returns the user authorization for a given authorization id 5038 This method makes a synchronous HTTP request by default. To make an 5039 asynchronous HTTP request, please define a `callback` function 5040 to be invoked when receiving the response. 5041 >>> def callback_function(response): 5042 >>> pprint(response) 5043 >>> 5044 >>> thread = api.get_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 5045 5046 :param callback function: The callback function 5047 for asynchronous request. (optional) 5048 :param str account_id: The external account number (int) or account ID Guid. (required) 5049 :param str authorization_id: (required) 5050 :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) 5051 :return: UserAuthorization 5052 If the method is called asynchronously, 5053 returns the request thread. 5054 """ 5055 5056 all_params = ['account_id', 'authorization_id', 'user_id'] 5057 all_params.append('callback') 5058 all_params.append('_return_http_data_only') 5059 all_params.append('_preload_content') 5060 all_params.append('_request_timeout') 5061 5062 params = locals() 5063 for key, val in iteritems(params['kwargs']): 5064 if key not in all_params: 5065 raise TypeError( 5066 "Got an unexpected keyword argument '%s'" 5067 " to method get_user_authorization" % key 5068 ) 5069 params[key] = val 5070 del params['kwargs'] 5071 # verify the required parameter 'account_id' is set 5072 if ('account_id' not in params) or (params['account_id'] is None): 5073 raise ValueError("Missing the required parameter `account_id` when calling `get_user_authorization`") 5074 # verify the required parameter 'authorization_id' is set 5075 if ('authorization_id' not in params) or (params['authorization_id'] is None): 5076 raise ValueError("Missing the required parameter `authorization_id` when calling `get_user_authorization`") 5077 # verify the required parameter 'user_id' is set 5078 if ('user_id' not in params) or (params['user_id'] is None): 5079 raise ValueError("Missing the required parameter `user_id` when calling `get_user_authorization`") 5080 5081 5082 collection_formats = {} 5083 5084 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 5085 path_params = {} 5086 if 'account_id' in params: 5087 path_params['accountId'] = params['account_id'] 5088 if 'authorization_id' in params: 5089 path_params['authorizationId'] = params['authorization_id'] 5090 if 'user_id' in params: 5091 path_params['userId'] = params['user_id'] 5092 5093 query_params = {} 5094 5095 header_params = {} 5096 5097 form_params = [] 5098 local_var_files = {} 5099 5100 body_params = None 5101 # HTTP header `Accept` 5102 header_params['Accept'] = self.api_client.\ 5103 select_header_accept(['application/json']) 5104 5105 # Authentication setting 5106 auth_settings = [] 5107 5108 return self.api_client.call_api(resource_path, 'GET', 5109 path_params, 5110 query_params, 5111 header_params, 5112 body=body_params, 5113 post_params=form_params, 5114 files=local_var_files, 5115 response_type='UserAuthorization', 5116 auth_settings=auth_settings, 5117 callback=params.get('callback'), 5118 _return_http_data_only=params.get('_return_http_data_only'), 5119 _preload_content=params.get('_preload_content', True), 5120 _request_timeout=params.get('_request_timeout'), 5121 collection_formats=collection_formats) 5122 5123 def get_watermark(self, account_id, **kwargs): 5124 """ 5125 Get watermark information. 5126 5127 This method makes a synchronous HTTP request by default. To make an 5128 asynchronous HTTP request, please define a `callback` function 5129 to be invoked when receiving the response. 5130 >>> def callback_function(response): 5131 >>> pprint(response) 5132 >>> 5133 >>> thread = api.get_watermark(account_id, callback=callback_function) 5134 5135 :param callback function: The callback function 5136 for asynchronous request. (optional) 5137 :param str account_id: The external account number (int) or account ID Guid. (required) 5138 :return: Watermark 5139 If the method is called asynchronously, 5140 returns the request thread. 5141 """ 5142 kwargs['_return_http_data_only'] = True 5143 if kwargs.get('callback'): 5144 return self.get_watermark_with_http_info(account_id, **kwargs) 5145 else: 5146 (data) = self.get_watermark_with_http_info(account_id, **kwargs) 5147 return data 5148 5149 def get_watermark_with_http_info(self, account_id, **kwargs): 5150 """ 5151 Get watermark information. 5152 5153 This method makes a synchronous HTTP request by default. To make an 5154 asynchronous HTTP request, please define a `callback` function 5155 to be invoked when receiving the response. 5156 >>> def callback_function(response): 5157 >>> pprint(response) 5158 >>> 5159 >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function) 5160 5161 :param callback function: The callback function 5162 for asynchronous request. (optional) 5163 :param str account_id: The external account number (int) or account ID Guid. (required) 5164 :return: Watermark 5165 If the method is called asynchronously, 5166 returns the request thread. 5167 """ 5168 5169 all_params = ['account_id'] 5170 all_params.append('callback') 5171 all_params.append('_return_http_data_only') 5172 all_params.append('_preload_content') 5173 all_params.append('_request_timeout') 5174 5175 params = locals() 5176 for key, val in iteritems(params['kwargs']): 5177 if key not in all_params: 5178 raise TypeError( 5179 "Got an unexpected keyword argument '%s'" 5180 " to method get_watermark" % key 5181 ) 5182 params[key] = val 5183 del params['kwargs'] 5184 # verify the required parameter 'account_id' is set 5185 if ('account_id' not in params) or (params['account_id'] is None): 5186 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`") 5187 5188 5189 collection_formats = {} 5190 5191 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 5192 path_params = {} 5193 if 'account_id' in params: 5194 path_params['accountId'] = params['account_id'] 5195 5196 query_params = {} 5197 5198 header_params = {} 5199 5200 form_params = [] 5201 local_var_files = {} 5202 5203 body_params = None 5204 # HTTP header `Accept` 5205 header_params['Accept'] = self.api_client.\ 5206 select_header_accept(['application/json']) 5207 5208 # Authentication setting 5209 auth_settings = [] 5210 5211 return self.api_client.call_api(resource_path, 'GET', 5212 path_params, 5213 query_params, 5214 header_params, 5215 body=body_params, 5216 post_params=form_params, 5217 files=local_var_files, 5218 response_type='Watermark', 5219 auth_settings=auth_settings, 5220 callback=params.get('callback'), 5221 _return_http_data_only=params.get('_return_http_data_only'), 5222 _preload_content=params.get('_preload_content', True), 5223 _request_timeout=params.get('_request_timeout'), 5224 collection_formats=collection_formats) 5225 5226 def get_watermark_preview(self, account_id, **kwargs): 5227 """ 5228 Get watermark preview. 5229 5230 This method makes a synchronous HTTP request by default. To make an 5231 asynchronous HTTP request, please define a `callback` function 5232 to be invoked when receiving the response. 5233 >>> def callback_function(response): 5234 >>> pprint(response) 5235 >>> 5236 >>> thread = api.get_watermark_preview(account_id, callback=callback_function) 5237 5238 :param callback function: The callback function 5239 for asynchronous request. (optional) 5240 :param str account_id: The external account number (int) or account ID Guid. (required) 5241 :param Watermark watermark: 5242 :return: Watermark 5243 If the method is called asynchronously, 5244 returns the request thread. 5245 """ 5246 kwargs['_return_http_data_only'] = True 5247 if kwargs.get('callback'): 5248 return self.get_watermark_preview_with_http_info(account_id, **kwargs) 5249 else: 5250 (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs) 5251 return data 5252 5253 def get_watermark_preview_with_http_info(self, account_id, **kwargs): 5254 """ 5255 Get watermark preview. 5256 5257 This method makes a synchronous HTTP request by default. To make an 5258 asynchronous HTTP request, please define a `callback` function 5259 to be invoked when receiving the response. 5260 >>> def callback_function(response): 5261 >>> pprint(response) 5262 >>> 5263 >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function) 5264 5265 :param callback function: The callback function 5266 for asynchronous request. (optional) 5267 :param str account_id: The external account number (int) or account ID Guid. (required) 5268 :param Watermark watermark: 5269 :return: Watermark 5270 If the method is called asynchronously, 5271 returns the request thread. 5272 """ 5273 5274 all_params = ['account_id', 'watermark'] 5275 all_params.append('callback') 5276 all_params.append('_return_http_data_only') 5277 all_params.append('_preload_content') 5278 all_params.append('_request_timeout') 5279 5280 params = locals() 5281 for key, val in iteritems(params['kwargs']): 5282 if key not in all_params: 5283 raise TypeError( 5284 "Got an unexpected keyword argument '%s'" 5285 " to method get_watermark_preview" % key 5286 ) 5287 params[key] = val 5288 del params['kwargs'] 5289 # verify the required parameter 'account_id' is set 5290 if ('account_id' not in params) or (params['account_id'] is None): 5291 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`") 5292 5293 5294 collection_formats = {} 5295 5296 resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json') 5297 path_params = {} 5298 if 'account_id' in params: 5299 path_params['accountId'] = params['account_id'] 5300 5301 query_params = {} 5302 5303 header_params = {} 5304 5305 form_params = [] 5306 local_var_files = {} 5307 5308 body_params = None 5309 if 'watermark' in params: 5310 body_params = params['watermark'] 5311 # HTTP header `Accept` 5312 header_params['Accept'] = self.api_client.\ 5313 select_header_accept(['application/json']) 5314 5315 # Authentication setting 5316 auth_settings = [] 5317 5318 return self.api_client.call_api(resource_path, 'PUT', 5319 path_params, 5320 query_params, 5321 header_params, 5322 body=body_params, 5323 post_params=form_params, 5324 files=local_var_files, 5325 response_type='Watermark', 5326 auth_settings=auth_settings, 5327 callback=params.get('callback'), 5328 _return_http_data_only=params.get('_return_http_data_only'), 5329 _preload_content=params.get('_preload_content', True), 5330 _request_timeout=params.get('_request_timeout'), 5331 collection_formats=collection_formats) 5332 5333 def list_brands(self, account_id, **kwargs): 5334 """ 5335 Gets a list of brand profiles. 5336 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. 5337 This method makes a synchronous HTTP request by default. To make an 5338 asynchronous HTTP request, please define a `callback` function 5339 to be invoked when receiving the response. 5340 >>> def callback_function(response): 5341 >>> pprint(response) 5342 >>> 5343 >>> thread = api.list_brands(account_id, callback=callback_function) 5344 5345 :param callback function: The callback function 5346 for asynchronous request. (optional) 5347 :param str account_id: The external account number (int) or account ID Guid. (required) 5348 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5349 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5350 :return: BrandsResponse 5351 If the method is called asynchronously, 5352 returns the request thread. 5353 """ 5354 kwargs['_return_http_data_only'] = True 5355 if kwargs.get('callback'): 5356 return self.list_brands_with_http_info(account_id, **kwargs) 5357 else: 5358 (data) = self.list_brands_with_http_info(account_id, **kwargs) 5359 return data 5360 5361 def list_brands_with_http_info(self, account_id, **kwargs): 5362 """ 5363 Gets a list of brand profiles. 5364 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. 5365 This method makes a synchronous HTTP request by default. To make an 5366 asynchronous HTTP request, please define a `callback` function 5367 to be invoked when receiving the response. 5368 >>> def callback_function(response): 5369 >>> pprint(response) 5370 >>> 5371 >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function) 5372 5373 :param callback function: The callback function 5374 for asynchronous request. (optional) 5375 :param str account_id: The external account number (int) or account ID Guid. (required) 5376 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5377 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5378 :return: BrandsResponse 5379 If the method is called asynchronously, 5380 returns the request thread. 5381 """ 5382 5383 all_params = ['account_id', 'exclude_distributor_brand', 'include_logos'] 5384 all_params.append('callback') 5385 all_params.append('_return_http_data_only') 5386 all_params.append('_preload_content') 5387 all_params.append('_request_timeout') 5388 5389 params = locals() 5390 for key, val in iteritems(params['kwargs']): 5391 if key not in all_params: 5392 raise TypeError( 5393 "Got an unexpected keyword argument '%s'" 5394 " to method list_brands" % key 5395 ) 5396 params[key] = val 5397 del params['kwargs'] 5398 # verify the required parameter 'account_id' is set 5399 if ('account_id' not in params) or (params['account_id'] is None): 5400 raise ValueError("Missing the required parameter `account_id` when calling `list_brands`") 5401 5402 5403 collection_formats = {} 5404 5405 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 5406 path_params = {} 5407 if 'account_id' in params: 5408 path_params['accountId'] = params['account_id'] 5409 5410 query_params = {} 5411 if 'exclude_distributor_brand' in params: 5412 query_params['exclude_distributor_brand'] = params['exclude_distributor_brand'] 5413 if 'include_logos' in params: 5414 query_params['include_logos'] = params['include_logos'] 5415 5416 header_params = {} 5417 5418 form_params = [] 5419 local_var_files = {} 5420 5421 body_params = None 5422 # HTTP header `Accept` 5423 header_params['Accept'] = self.api_client.\ 5424 select_header_accept(['application/json']) 5425 5426 # Authentication setting 5427 auth_settings = [] 5428 5429 return self.api_client.call_api(resource_path, 'GET', 5430 path_params, 5431 query_params, 5432 header_params, 5433 body=body_params, 5434 post_params=form_params, 5435 files=local_var_files, 5436 response_type='BrandsResponse', 5437 auth_settings=auth_settings, 5438 callback=params.get('callback'), 5439 _return_http_data_only=params.get('_return_http_data_only'), 5440 _preload_content=params.get('_preload_content', True), 5441 _request_timeout=params.get('_request_timeout'), 5442 collection_formats=collection_formats) 5443 5444 def list_custom_fields(self, account_id, **kwargs): 5445 """ 5446 Gets a list of custom fields associated with the account. 5447 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. 5448 This method makes a synchronous HTTP request by default. To make an 5449 asynchronous HTTP request, please define a `callback` function 5450 to be invoked when receiving the response. 5451 >>> def callback_function(response): 5452 >>> pprint(response) 5453 >>> 5454 >>> thread = api.list_custom_fields(account_id, callback=callback_function) 5455 5456 :param callback function: The callback function 5457 for asynchronous request. (optional) 5458 :param str account_id: The external account number (int) or account ID Guid. (required) 5459 :return: CustomFields 5460 If the method is called asynchronously, 5461 returns the request thread. 5462 """ 5463 kwargs['_return_http_data_only'] = True 5464 if kwargs.get('callback'): 5465 return self.list_custom_fields_with_http_info(account_id, **kwargs) 5466 else: 5467 (data) = self.list_custom_fields_with_http_info(account_id, **kwargs) 5468 return data 5469 5470 def list_custom_fields_with_http_info(self, account_id, **kwargs): 5471 """ 5472 Gets a list of custom fields associated with the account. 5473 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. 5474 This method makes a synchronous HTTP request by default. To make an 5475 asynchronous HTTP request, please define a `callback` function 5476 to be invoked when receiving the response. 5477 >>> def callback_function(response): 5478 >>> pprint(response) 5479 >>> 5480 >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function) 5481 5482 :param callback function: The callback function 5483 for asynchronous request. (optional) 5484 :param str account_id: The external account number (int) or account ID Guid. (required) 5485 :return: CustomFields 5486 If the method is called asynchronously, 5487 returns the request thread. 5488 """ 5489 5490 all_params = ['account_id'] 5491 all_params.append('callback') 5492 all_params.append('_return_http_data_only') 5493 all_params.append('_preload_content') 5494 all_params.append('_request_timeout') 5495 5496 params = locals() 5497 for key, val in iteritems(params['kwargs']): 5498 if key not in all_params: 5499 raise TypeError( 5500 "Got an unexpected keyword argument '%s'" 5501 " to method list_custom_fields" % key 5502 ) 5503 params[key] = val 5504 del params['kwargs'] 5505 # verify the required parameter 'account_id' is set 5506 if ('account_id' not in params) or (params['account_id'] is None): 5507 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 5508 5509 5510 collection_formats = {} 5511 5512 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 5513 path_params = {} 5514 if 'account_id' in params: 5515 path_params['accountId'] = params['account_id'] 5516 5517 query_params = {} 5518 5519 header_params = {} 5520 5521 form_params = [] 5522 local_var_files = {} 5523 5524 body_params = None 5525 # HTTP header `Accept` 5526 header_params['Accept'] = self.api_client.\ 5527 select_header_accept(['application/json']) 5528 5529 # Authentication setting 5530 auth_settings = [] 5531 5532 return self.api_client.call_api(resource_path, 'GET', 5533 path_params, 5534 query_params, 5535 header_params, 5536 body=body_params, 5537 post_params=form_params, 5538 files=local_var_files, 5539 response_type='CustomFields', 5540 auth_settings=auth_settings, 5541 callback=params.get('callback'), 5542 _return_http_data_only=params.get('_return_http_data_only'), 5543 _preload_content=params.get('_preload_content', True), 5544 _request_timeout=params.get('_request_timeout'), 5545 collection_formats=collection_formats) 5546 5547 def list_permissions(self, account_id, **kwargs): 5548 """ 5549 Gets a list of permission profiles. 5550 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. 5551 This method makes a synchronous HTTP request by default. To make an 5552 asynchronous HTTP request, please define a `callback` function 5553 to be invoked when receiving the response. 5554 >>> def callback_function(response): 5555 >>> pprint(response) 5556 >>> 5557 >>> thread = api.list_permissions(account_id, callback=callback_function) 5558 5559 :param callback function: The callback function 5560 for asynchronous request. (optional) 5561 :param str account_id: The external account number (int) or account ID Guid. (required) 5562 :param str include: 5563 :return: PermissionProfileInformation 5564 If the method is called asynchronously, 5565 returns the request thread. 5566 """ 5567 kwargs['_return_http_data_only'] = True 5568 if kwargs.get('callback'): 5569 return self.list_permissions_with_http_info(account_id, **kwargs) 5570 else: 5571 (data) = self.list_permissions_with_http_info(account_id, **kwargs) 5572 return data 5573 5574 def list_permissions_with_http_info(self, account_id, **kwargs): 5575 """ 5576 Gets a list of permission profiles. 5577 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. 5578 This method makes a synchronous HTTP request by default. To make an 5579 asynchronous HTTP request, please define a `callback` function 5580 to be invoked when receiving the response. 5581 >>> def callback_function(response): 5582 >>> pprint(response) 5583 >>> 5584 >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function) 5585 5586 :param callback function: The callback function 5587 for asynchronous request. (optional) 5588 :param str account_id: The external account number (int) or account ID Guid. (required) 5589 :param str include: 5590 :return: PermissionProfileInformation 5591 If the method is called asynchronously, 5592 returns the request thread. 5593 """ 5594 5595 all_params = ['account_id', 'include'] 5596 all_params.append('callback') 5597 all_params.append('_return_http_data_only') 5598 all_params.append('_preload_content') 5599 all_params.append('_request_timeout') 5600 5601 params = locals() 5602 for key, val in iteritems(params['kwargs']): 5603 if key not in all_params: 5604 raise TypeError( 5605 "Got an unexpected keyword argument '%s'" 5606 " to method list_permissions" % key 5607 ) 5608 params[key] = val 5609 del params['kwargs'] 5610 # verify the required parameter 'account_id' is set 5611 if ('account_id' not in params) or (params['account_id'] is None): 5612 raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`") 5613 5614 5615 collection_formats = {} 5616 5617 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 5618 path_params = {} 5619 if 'account_id' in params: 5620 path_params['accountId'] = params['account_id'] 5621 5622 query_params = {} 5623 if 'include' in params: 5624 query_params['include'] = params['include'] 5625 5626 header_params = {} 5627 5628 form_params = [] 5629 local_var_files = {} 5630 5631 body_params = None 5632 # HTTP header `Accept` 5633 header_params['Accept'] = self.api_client.\ 5634 select_header_accept(['application/json']) 5635 5636 # Authentication setting 5637 auth_settings = [] 5638 5639 return self.api_client.call_api(resource_path, 'GET', 5640 path_params, 5641 query_params, 5642 header_params, 5643 body=body_params, 5644 post_params=form_params, 5645 files=local_var_files, 5646 response_type='PermissionProfileInformation', 5647 auth_settings=auth_settings, 5648 callback=params.get('callback'), 5649 _return_http_data_only=params.get('_return_http_data_only'), 5650 _preload_content=params.get('_preload_content', True), 5651 _request_timeout=params.get('_request_timeout'), 5652 collection_formats=collection_formats) 5653 5654 def list_recipient_names_by_email(self, account_id, **kwargs): 5655 """ 5656 Gets recipient names associated with an email address. 5657 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5658 This method makes a synchronous HTTP request by default. To make an 5659 asynchronous HTTP request, please define a `callback` function 5660 to be invoked when receiving the response. 5661 >>> def callback_function(response): 5662 >>> pprint(response) 5663 >>> 5664 >>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function) 5665 5666 :param callback function: The callback function 5667 for asynchronous request. (optional) 5668 :param str account_id: The external account number (int) or account ID Guid. (required) 5669 :param str email: The email address for the user 5670 :return: RecipientNamesResponse 5671 If the method is called asynchronously, 5672 returns the request thread. 5673 """ 5674 kwargs['_return_http_data_only'] = True 5675 if kwargs.get('callback'): 5676 return self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5677 else: 5678 (data) = self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5679 return data 5680 5681 def list_recipient_names_by_email_with_http_info(self, account_id, **kwargs): 5682 """ 5683 Gets recipient names associated with an email address. 5684 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5685 This method makes a synchronous HTTP request by default. To make an 5686 asynchronous HTTP request, please define a `callback` function 5687 to be invoked when receiving the response. 5688 >>> def callback_function(response): 5689 >>> pprint(response) 5690 >>> 5691 >>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function) 5692 5693 :param callback function: The callback function 5694 for asynchronous request. (optional) 5695 :param str account_id: The external account number (int) or account ID Guid. (required) 5696 :param str email: The email address for the user 5697 :return: RecipientNamesResponse 5698 If the method is called asynchronously, 5699 returns the request thread. 5700 """ 5701 5702 all_params = ['account_id', 'email'] 5703 all_params.append('callback') 5704 all_params.append('_return_http_data_only') 5705 all_params.append('_preload_content') 5706 all_params.append('_request_timeout') 5707 5708 params = locals() 5709 for key, val in iteritems(params['kwargs']): 5710 if key not in all_params: 5711 raise TypeError( 5712 "Got an unexpected keyword argument '%s'" 5713 " to method list_recipient_names_by_email" % key 5714 ) 5715 params[key] = val 5716 del params['kwargs'] 5717 # verify the required parameter 'account_id' is set 5718 if ('account_id' not in params) or (params['account_id'] is None): 5719 raise ValueError("Missing the required parameter `account_id` when calling `list_recipient_names_by_email`") 5720 5721 5722 collection_formats = {} 5723 5724 resource_path = '/v2.1/accounts/{accountId}/recipient_names'.replace('{format}', 'json') 5725 path_params = {} 5726 if 'account_id' in params: 5727 path_params['accountId'] = params['account_id'] 5728 5729 query_params = {} 5730 if 'email' in params: 5731 query_params['email'] = params['email'] 5732 5733 header_params = {} 5734 5735 form_params = [] 5736 local_var_files = {} 5737 5738 body_params = None 5739 # HTTP header `Accept` 5740 header_params['Accept'] = self.api_client.\ 5741 select_header_accept(['application/json']) 5742 5743 # Authentication setting 5744 auth_settings = [] 5745 5746 return self.api_client.call_api(resource_path, 'GET', 5747 path_params, 5748 query_params, 5749 header_params, 5750 body=body_params, 5751 post_params=form_params, 5752 files=local_var_files, 5753 response_type='RecipientNamesResponse', 5754 auth_settings=auth_settings, 5755 callback=params.get('callback'), 5756 _return_http_data_only=params.get('_return_http_data_only'), 5757 _preload_content=params.get('_preload_content', True), 5758 _request_timeout=params.get('_request_timeout'), 5759 collection_formats=collection_formats) 5760 5761 def list_settings(self, account_id, **kwargs): 5762 """ 5763 Gets account settings information. 5764 Retrieves the account settings information for the specified account. 5765 This method makes a synchronous HTTP request by default. To make an 5766 asynchronous HTTP request, please define a `callback` function 5767 to be invoked when receiving the response. 5768 >>> def callback_function(response): 5769 >>> pprint(response) 5770 >>> 5771 >>> thread = api.list_settings(account_id, callback=callback_function) 5772 5773 :param callback function: The callback function 5774 for asynchronous request. (optional) 5775 :param str account_id: The external account number (int) or account ID Guid. (required) 5776 :return: AccountSettingsInformation 5777 If the method is called asynchronously, 5778 returns the request thread. 5779 """ 5780 kwargs['_return_http_data_only'] = True 5781 if kwargs.get('callback'): 5782 return self.list_settings_with_http_info(account_id, **kwargs) 5783 else: 5784 (data) = self.list_settings_with_http_info(account_id, **kwargs) 5785 return data 5786 5787 def list_settings_with_http_info(self, account_id, **kwargs): 5788 """ 5789 Gets account settings information. 5790 Retrieves the account settings information for the specified account. 5791 This method makes a synchronous HTTP request by default. To make an 5792 asynchronous HTTP request, please define a `callback` function 5793 to be invoked when receiving the response. 5794 >>> def callback_function(response): 5795 >>> pprint(response) 5796 >>> 5797 >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function) 5798 5799 :param callback function: The callback function 5800 for asynchronous request. (optional) 5801 :param str account_id: The external account number (int) or account ID Guid. (required) 5802 :return: AccountSettingsInformation 5803 If the method is called asynchronously, 5804 returns the request thread. 5805 """ 5806 5807 all_params = ['account_id'] 5808 all_params.append('callback') 5809 all_params.append('_return_http_data_only') 5810 all_params.append('_preload_content') 5811 all_params.append('_request_timeout') 5812 5813 params = locals() 5814 for key, val in iteritems(params['kwargs']): 5815 if key not in all_params: 5816 raise TypeError( 5817 "Got an unexpected keyword argument '%s'" 5818 " to method list_settings" % key 5819 ) 5820 params[key] = val 5821 del params['kwargs'] 5822 # verify the required parameter 'account_id' is set 5823 if ('account_id' not in params) or (params['account_id'] is None): 5824 raise ValueError("Missing the required parameter `account_id` when calling `list_settings`") 5825 5826 5827 collection_formats = {} 5828 5829 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 5830 path_params = {} 5831 if 'account_id' in params: 5832 path_params['accountId'] = params['account_id'] 5833 5834 query_params = {} 5835 5836 header_params = {} 5837 5838 form_params = [] 5839 local_var_files = {} 5840 5841 body_params = None 5842 # HTTP header `Accept` 5843 header_params['Accept'] = self.api_client.\ 5844 select_header_accept(['application/json']) 5845 5846 # Authentication setting 5847 auth_settings = [] 5848 5849 return self.api_client.call_api(resource_path, 'GET', 5850 path_params, 5851 query_params, 5852 header_params, 5853 body=body_params, 5854 post_params=form_params, 5855 files=local_var_files, 5856 response_type='AccountSettingsInformation', 5857 auth_settings=auth_settings, 5858 callback=params.get('callback'), 5859 _return_http_data_only=params.get('_return_http_data_only'), 5860 _preload_content=params.get('_preload_content', True), 5861 _request_timeout=params.get('_request_timeout'), 5862 collection_formats=collection_formats) 5863 5864 def list_shared_access(self, account_id, **kwargs): 5865 """ 5866 Reserved: Gets the shared item status for one or more users. 5867 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. 5868 This method makes a synchronous HTTP request by default. To make an 5869 asynchronous HTTP request, please define a `callback` function 5870 to be invoked when receiving the response. 5871 >>> def callback_function(response): 5872 >>> pprint(response) 5873 >>> 5874 >>> thread = api.list_shared_access(account_id, callback=callback_function) 5875 5876 :param callback function: The callback function 5877 for asynchronous request. (optional) 5878 :param str account_id: The external account number (int) or account ID Guid. (required) 5879 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5880 :param str envelopes_not_shared_user_status: 5881 :param str folder_ids: 5882 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5883 :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. 5884 :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 5885 :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. 5886 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 5887 :return: AccountSharedAccess 5888 If the method is called asynchronously, 5889 returns the request thread. 5890 """ 5891 kwargs['_return_http_data_only'] = True 5892 if kwargs.get('callback'): 5893 return self.list_shared_access_with_http_info(account_id, **kwargs) 5894 else: 5895 (data) = self.list_shared_access_with_http_info(account_id, **kwargs) 5896 return data 5897 5898 def list_shared_access_with_http_info(self, account_id, **kwargs): 5899 """ 5900 Reserved: Gets the shared item status for one or more users. 5901 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. 5902 This method makes a synchronous HTTP request by default. To make an 5903 asynchronous HTTP request, please define a `callback` function 5904 to be invoked when receiving the response. 5905 >>> def callback_function(response): 5906 >>> pprint(response) 5907 >>> 5908 >>> thread = api.list_shared_access_with_http_info(account_id, callback=callback_function) 5909 5910 :param callback function: The callback function 5911 for asynchronous request. (optional) 5912 :param str account_id: The external account number (int) or account ID Guid. (required) 5913 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5914 :param str envelopes_not_shared_user_status: 5915 :param str folder_ids: 5916 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5917 :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. 5918 :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 5919 :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. 5920 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 5921 :return: AccountSharedAccess 5922 If the method is called asynchronously, 5923 returns the request thread. 5924 """ 5925 5926 all_params = ['account_id', 'count', 'envelopes_not_shared_user_status', 'folder_ids', 'item_type', 'search_text', 'shared', 'start_position', 'user_ids'] 5927 all_params.append('callback') 5928 all_params.append('_return_http_data_only') 5929 all_params.append('_preload_content') 5930 all_params.append('_request_timeout') 5931 5932 params = locals() 5933 for key, val in iteritems(params['kwargs']): 5934 if key not in all_params: 5935 raise TypeError( 5936 "Got an unexpected keyword argument '%s'" 5937 " to method list_shared_access" % key 5938 ) 5939 params[key] = val 5940 del params['kwargs'] 5941 # verify the required parameter 'account_id' is set 5942 if ('account_id' not in params) or (params['account_id'] is None): 5943 raise ValueError("Missing the required parameter `account_id` when calling `list_shared_access`") 5944 5945 5946 collection_formats = {} 5947 5948 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 5949 path_params = {} 5950 if 'account_id' in params: 5951 path_params['accountId'] = params['account_id'] 5952 5953 query_params = {} 5954 if 'count' in params: 5955 query_params['count'] = params['count'] 5956 if 'envelopes_not_shared_user_status' in params: 5957 query_params['envelopes_not_shared_user_status'] = params['envelopes_not_shared_user_status'] 5958 if 'folder_ids' in params: 5959 query_params['folder_ids'] = params['folder_ids'] 5960 if 'item_type' in params: 5961 query_params['item_type'] = params['item_type'] 5962 if 'search_text' in params: 5963 query_params['search_text'] = params['search_text'] 5964 if 'shared' in params: 5965 query_params['shared'] = params['shared'] 5966 if 'start_position' in params: 5967 query_params['start_position'] = params['start_position'] 5968 if 'user_ids' in params: 5969 query_params['user_ids'] = params['user_ids'] 5970 5971 header_params = {} 5972 5973 form_params = [] 5974 local_var_files = {} 5975 5976 body_params = None 5977 # HTTP header `Accept` 5978 header_params['Accept'] = self.api_client.\ 5979 select_header_accept(['application/json']) 5980 5981 # Authentication setting 5982 auth_settings = [] 5983 5984 return self.api_client.call_api(resource_path, 'GET', 5985 path_params, 5986 query_params, 5987 header_params, 5988 body=body_params, 5989 post_params=form_params, 5990 files=local_var_files, 5991 response_type='AccountSharedAccess', 5992 auth_settings=auth_settings, 5993 callback=params.get('callback'), 5994 _return_http_data_only=params.get('_return_http_data_only'), 5995 _preload_content=params.get('_preload_content', True), 5996 _request_timeout=params.get('_request_timeout'), 5997 collection_formats=collection_formats) 5998 5999 def list_signature_providers(self, account_id, **kwargs): 6000 """ 6001 Returns Account available signature providers for specified account. 6002 Returns a list of signature providers that the specified account can use. 6003 This method makes a synchronous HTTP request by default. To make an 6004 asynchronous HTTP request, please define a `callback` function 6005 to be invoked when receiving the response. 6006 >>> def callback_function(response): 6007 >>> pprint(response) 6008 >>> 6009 >>> thread = api.list_signature_providers(account_id, callback=callback_function) 6010 6011 :param callback function: The callback function 6012 for asynchronous request. (optional) 6013 :param str account_id: The external account number (int) or account ID Guid. (required) 6014 :return: AccountSignatureProviders 6015 If the method is called asynchronously, 6016 returns the request thread. 6017 """ 6018 kwargs['_return_http_data_only'] = True 6019 if kwargs.get('callback'): 6020 return self.list_signature_providers_with_http_info(account_id, **kwargs) 6021 else: 6022 (data) = self.list_signature_providers_with_http_info(account_id, **kwargs) 6023 return data 6024 6025 def list_signature_providers_with_http_info(self, account_id, **kwargs): 6026 """ 6027 Returns Account available signature providers for specified account. 6028 Returns a list of signature providers that the specified account can use. 6029 This method makes a synchronous HTTP request by default. To make an 6030 asynchronous HTTP request, please define a `callback` function 6031 to be invoked when receiving the response. 6032 >>> def callback_function(response): 6033 >>> pprint(response) 6034 >>> 6035 >>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function) 6036 6037 :param callback function: The callback function 6038 for asynchronous request. (optional) 6039 :param str account_id: The external account number (int) or account ID Guid. (required) 6040 :return: AccountSignatureProviders 6041 If the method is called asynchronously, 6042 returns the request thread. 6043 """ 6044 6045 all_params = ['account_id'] 6046 all_params.append('callback') 6047 all_params.append('_return_http_data_only') 6048 all_params.append('_preload_content') 6049 all_params.append('_request_timeout') 6050 6051 params = locals() 6052 for key, val in iteritems(params['kwargs']): 6053 if key not in all_params: 6054 raise TypeError( 6055 "Got an unexpected keyword argument '%s'" 6056 " to method list_signature_providers" % key 6057 ) 6058 params[key] = val 6059 del params['kwargs'] 6060 # verify the required parameter 'account_id' is set 6061 if ('account_id' not in params) or (params['account_id'] is None): 6062 raise ValueError("Missing the required parameter `account_id` when calling `list_signature_providers`") 6063 6064 6065 collection_formats = {} 6066 6067 resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.replace('{format}', 'json') 6068 path_params = {} 6069 if 'account_id' in params: 6070 path_params['accountId'] = params['account_id'] 6071 6072 query_params = {} 6073 6074 header_params = {} 6075 6076 form_params = [] 6077 local_var_files = {} 6078 6079 body_params = None 6080 # HTTP header `Accept` 6081 header_params['Accept'] = self.api_client.\ 6082 select_header_accept(['application/json']) 6083 6084 # Authentication setting 6085 auth_settings = [] 6086 6087 return self.api_client.call_api(resource_path, 'GET', 6088 path_params, 6089 query_params, 6090 header_params, 6091 body=body_params, 6092 post_params=form_params, 6093 files=local_var_files, 6094 response_type='AccountSignatureProviders', 6095 auth_settings=auth_settings, 6096 callback=params.get('callback'), 6097 _return_http_data_only=params.get('_return_http_data_only'), 6098 _preload_content=params.get('_preload_content', True), 6099 _request_timeout=params.get('_request_timeout'), 6100 collection_formats=collection_formats) 6101 6102 def list_unsupported_file_types(self, account_id, **kwargs): 6103 """ 6104 Gets a list of unsupported file types. 6105 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6106 This method makes a synchronous HTTP request by default. To make an 6107 asynchronous HTTP request, please define a `callback` function 6108 to be invoked when receiving the response. 6109 >>> def callback_function(response): 6110 >>> pprint(response) 6111 >>> 6112 >>> thread = api.list_unsupported_file_types(account_id, callback=callback_function) 6113 6114 :param callback function: The callback function 6115 for asynchronous request. (optional) 6116 :param str account_id: The external account number (int) or account ID Guid. (required) 6117 :return: FileTypeList 6118 If the method is called asynchronously, 6119 returns the request thread. 6120 """ 6121 kwargs['_return_http_data_only'] = True 6122 if kwargs.get('callback'): 6123 return self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6124 else: 6125 (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6126 return data 6127 6128 def list_unsupported_file_types_with_http_info(self, account_id, **kwargs): 6129 """ 6130 Gets a list of unsupported file types. 6131 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6132 This method makes a synchronous HTTP request by default. To make an 6133 asynchronous HTTP request, please define a `callback` function 6134 to be invoked when receiving the response. 6135 >>> def callback_function(response): 6136 >>> pprint(response) 6137 >>> 6138 >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function) 6139 6140 :param callback function: The callback function 6141 for asynchronous request. (optional) 6142 :param str account_id: The external account number (int) or account ID Guid. (required) 6143 :return: FileTypeList 6144 If the method is called asynchronously, 6145 returns the request thread. 6146 """ 6147 6148 all_params = ['account_id'] 6149 all_params.append('callback') 6150 all_params.append('_return_http_data_only') 6151 all_params.append('_preload_content') 6152 all_params.append('_request_timeout') 6153 6154 params = locals() 6155 for key, val in iteritems(params['kwargs']): 6156 if key not in all_params: 6157 raise TypeError( 6158 "Got an unexpected keyword argument '%s'" 6159 " to method list_unsupported_file_types" % key 6160 ) 6161 params[key] = val 6162 del params['kwargs'] 6163 # verify the required parameter 'account_id' is set 6164 if ('account_id' not in params) or (params['account_id'] is None): 6165 raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`") 6166 6167 6168 collection_formats = {} 6169 6170 resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json') 6171 path_params = {} 6172 if 'account_id' in params: 6173 path_params['accountId'] = params['account_id'] 6174 6175 query_params = {} 6176 6177 header_params = {} 6178 6179 form_params = [] 6180 local_var_files = {} 6181 6182 body_params = None 6183 # HTTP header `Accept` 6184 header_params['Accept'] = self.api_client.\ 6185 select_header_accept(['application/json']) 6186 6187 # Authentication setting 6188 auth_settings = [] 6189 6190 return self.api_client.call_api(resource_path, 'GET', 6191 path_params, 6192 query_params, 6193 header_params, 6194 body=body_params, 6195 post_params=form_params, 6196 files=local_var_files, 6197 response_type='FileTypeList', 6198 auth_settings=auth_settings, 6199 callback=params.get('callback'), 6200 _return_http_data_only=params.get('_return_http_data_only'), 6201 _preload_content=params.get('_preload_content', True), 6202 _request_timeout=params.get('_request_timeout'), 6203 collection_formats=collection_formats) 6204 6205 def un_favorite_template(self, account_id, **kwargs): 6206 """ 6207 Unfavorite a template 6208 6209 This method makes a synchronous HTTP request by default. To make an 6210 asynchronous HTTP request, please define a `callback` function 6211 to be invoked when receiving the response. 6212 >>> def callback_function(response): 6213 >>> pprint(response) 6214 >>> 6215 >>> thread = api.un_favorite_template(account_id, callback=callback_function) 6216 6217 :param callback function: The callback function 6218 for asynchronous request. (optional) 6219 :param str account_id: The external account number (int) or account ID Guid. (required) 6220 :param FavoriteTemplatesInfo favorite_templates_info: 6221 :return: FavoriteTemplatesInfo 6222 If the method is called asynchronously, 6223 returns the request thread. 6224 """ 6225 kwargs['_return_http_data_only'] = True 6226 if kwargs.get('callback'): 6227 return self.un_favorite_template_with_http_info(account_id, **kwargs) 6228 else: 6229 (data) = self.un_favorite_template_with_http_info(account_id, **kwargs) 6230 return data 6231 6232 def un_favorite_template_with_http_info(self, account_id, **kwargs): 6233 """ 6234 Unfavorite a template 6235 6236 This method makes a synchronous HTTP request by default. To make an 6237 asynchronous HTTP request, please define a `callback` function 6238 to be invoked when receiving the response. 6239 >>> def callback_function(response): 6240 >>> pprint(response) 6241 >>> 6242 >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function) 6243 6244 :param callback function: The callback function 6245 for asynchronous request. (optional) 6246 :param str account_id: The external account number (int) or account ID Guid. (required) 6247 :param FavoriteTemplatesInfo favorite_templates_info: 6248 :return: FavoriteTemplatesInfo 6249 If the method is called asynchronously, 6250 returns the request thread. 6251 """ 6252 6253 all_params = ['account_id', 'favorite_templates_info'] 6254 all_params.append('callback') 6255 all_params.append('_return_http_data_only') 6256 all_params.append('_preload_content') 6257 all_params.append('_request_timeout') 6258 6259 params = locals() 6260 for key, val in iteritems(params['kwargs']): 6261 if key not in all_params: 6262 raise TypeError( 6263 "Got an unexpected keyword argument '%s'" 6264 " to method un_favorite_template" % key 6265 ) 6266 params[key] = val 6267 del params['kwargs'] 6268 # verify the required parameter 'account_id' is set 6269 if ('account_id' not in params) or (params['account_id'] is None): 6270 raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`") 6271 6272 6273 collection_formats = {} 6274 6275 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 6276 path_params = {} 6277 if 'account_id' in params: 6278 path_params['accountId'] = params['account_id'] 6279 6280 query_params = {} 6281 6282 header_params = {} 6283 6284 form_params = [] 6285 local_var_files = {} 6286 6287 body_params = None 6288 if 'favorite_templates_info' in params: 6289 body_params = params['favorite_templates_info'] 6290 # HTTP header `Accept` 6291 header_params['Accept'] = self.api_client.\ 6292 select_header_accept(['application/json']) 6293 6294 # Authentication setting 6295 auth_settings = [] 6296 6297 return self.api_client.call_api(resource_path, 'DELETE', 6298 path_params, 6299 query_params, 6300 header_params, 6301 body=body_params, 6302 post_params=form_params, 6303 files=local_var_files, 6304 response_type='FavoriteTemplatesInfo', 6305 auth_settings=auth_settings, 6306 callback=params.get('callback'), 6307 _return_http_data_only=params.get('_return_http_data_only'), 6308 _preload_content=params.get('_preload_content', True), 6309 _request_timeout=params.get('_request_timeout'), 6310 collection_formats=collection_formats) 6311 6312 def update_account_signature(self, account_id, **kwargs): 6313 """ 6314 Updates a account signature. 6315 6316 This method makes a synchronous HTTP request by default. To make an 6317 asynchronous HTTP request, please define a `callback` function 6318 to be invoked when receiving the response. 6319 >>> def callback_function(response): 6320 >>> pprint(response) 6321 >>> 6322 >>> thread = api.update_account_signature(account_id, callback=callback_function) 6323 6324 :param callback function: The callback function 6325 for asynchronous request. (optional) 6326 :param str account_id: The external account number (int) or account ID Guid. (required) 6327 :param AccountSignaturesInformation account_signatures_information: 6328 :return: AccountSignaturesInformation 6329 If the method is called asynchronously, 6330 returns the request thread. 6331 """ 6332 kwargs['_return_http_data_only'] = True 6333 if kwargs.get('callback'): 6334 return self.update_account_signature_with_http_info(account_id, **kwargs) 6335 else: 6336 (data) = self.update_account_signature_with_http_info(account_id, **kwargs) 6337 return data 6338 6339 def update_account_signature_with_http_info(self, account_id, **kwargs): 6340 """ 6341 Updates a account signature. 6342 6343 This method makes a synchronous HTTP request by default. To make an 6344 asynchronous HTTP request, please define a `callback` function 6345 to be invoked when receiving the response. 6346 >>> def callback_function(response): 6347 >>> pprint(response) 6348 >>> 6349 >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function) 6350 6351 :param callback function: The callback function 6352 for asynchronous request. (optional) 6353 :param str account_id: The external account number (int) or account ID Guid. (required) 6354 :param AccountSignaturesInformation account_signatures_information: 6355 :return: AccountSignaturesInformation 6356 If the method is called asynchronously, 6357 returns the request thread. 6358 """ 6359 6360 all_params = ['account_id', 'account_signatures_information'] 6361 all_params.append('callback') 6362 all_params.append('_return_http_data_only') 6363 all_params.append('_preload_content') 6364 all_params.append('_request_timeout') 6365 6366 params = locals() 6367 for key, val in iteritems(params['kwargs']): 6368 if key not in all_params: 6369 raise TypeError( 6370 "Got an unexpected keyword argument '%s'" 6371 " to method update_account_signature" % key 6372 ) 6373 params[key] = val 6374 del params['kwargs'] 6375 # verify the required parameter 'account_id' is set 6376 if ('account_id' not in params) or (params['account_id'] is None): 6377 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`") 6378 6379 6380 collection_formats = {} 6381 6382 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 6383 path_params = {} 6384 if 'account_id' in params: 6385 path_params['accountId'] = params['account_id'] 6386 6387 query_params = {} 6388 6389 header_params = {} 6390 6391 form_params = [] 6392 local_var_files = {} 6393 6394 body_params = None 6395 if 'account_signatures_information' in params: 6396 body_params = params['account_signatures_information'] 6397 # HTTP header `Accept` 6398 header_params['Accept'] = self.api_client.\ 6399 select_header_accept(['application/json']) 6400 6401 # Authentication setting 6402 auth_settings = [] 6403 6404 return self.api_client.call_api(resource_path, 'PUT', 6405 path_params, 6406 query_params, 6407 header_params, 6408 body=body_params, 6409 post_params=form_params, 6410 files=local_var_files, 6411 response_type='AccountSignaturesInformation', 6412 auth_settings=auth_settings, 6413 callback=params.get('callback'), 6414 _return_http_data_only=params.get('_return_http_data_only'), 6415 _preload_content=params.get('_preload_content', True), 6416 _request_timeout=params.get('_request_timeout'), 6417 collection_formats=collection_formats) 6418 6419 def update_account_signature_by_id(self, account_id, signature_id, **kwargs): 6420 """ 6421 Updates a account signature. 6422 6423 This method makes a synchronous HTTP request by default. To make an 6424 asynchronous HTTP request, please define a `callback` function 6425 to be invoked when receiving the response. 6426 >>> def callback_function(response): 6427 >>> pprint(response) 6428 >>> 6429 >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function) 6430 6431 :param callback function: The callback function 6432 for asynchronous request. (optional) 6433 :param str account_id: The external account number (int) or account ID Guid. (required) 6434 :param str signature_id: The ID of the signature being accessed. (required) 6435 :param str close_existing_signature: 6436 :param AccountSignatureDefinition account_signature_definition: 6437 :return: AccountSignature 6438 If the method is called asynchronously, 6439 returns the request thread. 6440 """ 6441 kwargs['_return_http_data_only'] = True 6442 if kwargs.get('callback'): 6443 return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6444 else: 6445 (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6446 return data 6447 6448 def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs): 6449 """ 6450 Updates a account signature. 6451 6452 This method makes a synchronous HTTP request by default. To make an 6453 asynchronous HTTP request, please define a `callback` function 6454 to be invoked when receiving the response. 6455 >>> def callback_function(response): 6456 >>> pprint(response) 6457 >>> 6458 >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function) 6459 6460 :param callback function: The callback function 6461 for asynchronous request. (optional) 6462 :param str account_id: The external account number (int) or account ID Guid. (required) 6463 :param str signature_id: The ID of the signature being accessed. (required) 6464 :param str close_existing_signature: 6465 :param AccountSignatureDefinition account_signature_definition: 6466 :return: AccountSignature 6467 If the method is called asynchronously, 6468 returns the request thread. 6469 """ 6470 6471 all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition'] 6472 all_params.append('callback') 6473 all_params.append('_return_http_data_only') 6474 all_params.append('_preload_content') 6475 all_params.append('_request_timeout') 6476 6477 params = locals() 6478 for key, val in iteritems(params['kwargs']): 6479 if key not in all_params: 6480 raise TypeError( 6481 "Got an unexpected keyword argument '%s'" 6482 " to method update_account_signature_by_id" % key 6483 ) 6484 params[key] = val 6485 del params['kwargs'] 6486 # verify the required parameter 'account_id' is set 6487 if ('account_id' not in params) or (params['account_id'] is None): 6488 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`") 6489 # verify the required parameter 'signature_id' is set 6490 if ('signature_id' not in params) or (params['signature_id'] is None): 6491 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`") 6492 6493 6494 collection_formats = {} 6495 6496 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 6497 path_params = {} 6498 if 'account_id' in params: 6499 path_params['accountId'] = params['account_id'] 6500 if 'signature_id' in params: 6501 path_params['signatureId'] = params['signature_id'] 6502 6503 query_params = {} 6504 if 'close_existing_signature' in params: 6505 query_params['close_existing_signature'] = params['close_existing_signature'] 6506 6507 header_params = {} 6508 6509 form_params = [] 6510 local_var_files = {} 6511 6512 body_params = None 6513 if 'account_signature_definition' in params: 6514 body_params = params['account_signature_definition'] 6515 # HTTP header `Accept` 6516 header_params['Accept'] = self.api_client.\ 6517 select_header_accept(['application/json']) 6518 6519 # Authentication setting 6520 auth_settings = [] 6521 6522 return self.api_client.call_api(resource_path, 'PUT', 6523 path_params, 6524 query_params, 6525 header_params, 6526 body=body_params, 6527 post_params=form_params, 6528 files=local_var_files, 6529 response_type='AccountSignature', 6530 auth_settings=auth_settings, 6531 callback=params.get('callback'), 6532 _return_http_data_only=params.get('_return_http_data_only'), 6533 _preload_content=params.get('_preload_content', True), 6534 _request_timeout=params.get('_request_timeout'), 6535 collection_formats=collection_formats) 6536 6537 def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 6538 """ 6539 Sets a signature, initials, or stamps image. 6540 6541 This method makes a synchronous HTTP request by default. To make an 6542 asynchronous HTTP request, please define a `callback` function 6543 to be invoked when receiving the response. 6544 >>> def callback_function(response): 6545 >>> pprint(response) 6546 >>> 6547 >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 6548 6549 :param callback function: The callback function 6550 for asynchronous request. (optional) 6551 :param str account_id: The external account number (int) or account ID Guid. (required) 6552 :param str image_type: One of **signature_image** or **initials_image**. (required) 6553 :param str signature_id: The ID of the signature being accessed. (required) 6554 :param str transparent_png: 6555 :return: AccountSignature 6556 If the method is called asynchronously, 6557 returns the request thread. 6558 """ 6559 kwargs['_return_http_data_only'] = True 6560 if kwargs.get('callback'): 6561 return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6562 else: 6563 (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6564 return data 6565 6566 def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 6567 """ 6568 Sets a signature, initials, or stamps image. 6569 6570 This method makes a synchronous HTTP request by default. To make an 6571 asynchronous HTTP request, please define a `callback` function 6572 to be invoked when receiving the response. 6573 >>> def callback_function(response): 6574 >>> pprint(response) 6575 >>> 6576 >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 6577 6578 :param callback function: The callback function 6579 for asynchronous request. (optional) 6580 :param str account_id: The external account number (int) or account ID Guid. (required) 6581 :param str image_type: One of **signature_image** or **initials_image**. (required) 6582 :param str signature_id: The ID of the signature being accessed. (required) 6583 :param str transparent_png: 6584 :return: AccountSignature 6585 If the method is called asynchronously, 6586 returns the request thread. 6587 """ 6588 6589 all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png'] 6590 all_params.append('callback') 6591 all_params.append('_return_http_data_only') 6592 all_params.append('_preload_content') 6593 all_params.append('_request_timeout') 6594 6595 params = locals() 6596 for key, val in iteritems(params['kwargs']): 6597 if key not in all_params: 6598 raise TypeError( 6599 "Got an unexpected keyword argument '%s'" 6600 " to method update_account_signature_image" % key 6601 ) 6602 params[key] = val 6603 del params['kwargs'] 6604 # verify the required parameter 'account_id' is set 6605 if ('account_id' not in params) or (params['account_id'] is None): 6606 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`") 6607 # verify the required parameter 'image_type' is set 6608 if ('image_type' not in params) or (params['image_type'] is None): 6609 raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`") 6610 # verify the required parameter 'signature_id' is set 6611 if ('signature_id' not in params) or (params['signature_id'] is None): 6612 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`") 6613 6614 6615 collection_formats = {} 6616 6617 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 6618 path_params = {} 6619 if 'account_id' in params: 6620 path_params['accountId'] = params['account_id'] 6621 if 'image_type' in params: 6622 path_params['imageType'] = params['image_type'] 6623 if 'signature_id' in params: 6624 path_params['signatureId'] = params['signature_id'] 6625 6626 query_params = {} 6627 if 'transparent_png' in params: 6628 query_params['transparent_png'] = params['transparent_png'] 6629 6630 header_params = {} 6631 6632 form_params = [] 6633 local_var_files = {} 6634 6635 body_params = None 6636 # HTTP header `Accept` 6637 header_params['Accept'] = self.api_client.\ 6638 select_header_accept(['application/json']) 6639 6640 # HTTP header `Content-Type` 6641 header_params['Content-Type'] = self.api_client.\ 6642 select_header_content_type(['image/gif']) 6643 6644 # Authentication setting 6645 auth_settings = [] 6646 6647 return self.api_client.call_api(resource_path, 'PUT', 6648 path_params, 6649 query_params, 6650 header_params, 6651 body=body_params, 6652 post_params=form_params, 6653 files=local_var_files, 6654 response_type='AccountSignature', 6655 auth_settings=auth_settings, 6656 callback=params.get('callback'), 6657 _return_http_data_only=params.get('_return_http_data_only'), 6658 _preload_content=params.get('_preload_content', True), 6659 _request_timeout=params.get('_request_timeout'), 6660 collection_formats=collection_formats) 6661 6662 def update_account_tab_settings(self, account_id, **kwargs): 6663 """ 6664 Modifies tab settings for specified account 6665 This method modifies the tab types and tab functionality that is enabled for an account. 6666 This method makes a synchronous HTTP request by default. To make an 6667 asynchronous HTTP request, please define a `callback` function 6668 to be invoked when receiving the response. 6669 >>> def callback_function(response): 6670 >>> pprint(response) 6671 >>> 6672 >>> thread = api.update_account_tab_settings(account_id, callback=callback_function) 6673 6674 :param callback function: The callback function 6675 for asynchronous request. (optional) 6676 :param str account_id: The external account number (int) or account ID Guid. (required) 6677 :param TabAccountSettings tab_account_settings: 6678 :return: TabAccountSettings 6679 If the method is called asynchronously, 6680 returns the request thread. 6681 """ 6682 kwargs['_return_http_data_only'] = True 6683 if kwargs.get('callback'): 6684 return self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6685 else: 6686 (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6687 return data 6688 6689 def update_account_tab_settings_with_http_info(self, account_id, **kwargs): 6690 """ 6691 Modifies tab settings for specified account 6692 This method modifies the tab types and tab functionality that is enabled for an account. 6693 This method makes a synchronous HTTP request by default. To make an 6694 asynchronous HTTP request, please define a `callback` function 6695 to be invoked when receiving the response. 6696 >>> def callback_function(response): 6697 >>> pprint(response) 6698 >>> 6699 >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function) 6700 6701 :param callback function: The callback function 6702 for asynchronous request. (optional) 6703 :param str account_id: The external account number (int) or account ID Guid. (required) 6704 :param TabAccountSettings tab_account_settings: 6705 :return: TabAccountSettings 6706 If the method is called asynchronously, 6707 returns the request thread. 6708 """ 6709 6710 all_params = ['account_id', 'tab_account_settings'] 6711 all_params.append('callback') 6712 all_params.append('_return_http_data_only') 6713 all_params.append('_preload_content') 6714 all_params.append('_request_timeout') 6715 6716 params = locals() 6717 for key, val in iteritems(params['kwargs']): 6718 if key not in all_params: 6719 raise TypeError( 6720 "Got an unexpected keyword argument '%s'" 6721 " to method update_account_tab_settings" % key 6722 ) 6723 params[key] = val 6724 del params['kwargs'] 6725 # verify the required parameter 'account_id' is set 6726 if ('account_id' not in params) or (params['account_id'] is None): 6727 raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`") 6728 6729 6730 collection_formats = {} 6731 6732 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 6733 path_params = {} 6734 if 'account_id' in params: 6735 path_params['accountId'] = params['account_id'] 6736 6737 query_params = {} 6738 6739 header_params = {} 6740 6741 form_params = [] 6742 local_var_files = {} 6743 6744 body_params = None 6745 if 'tab_account_settings' in params: 6746 body_params = params['tab_account_settings'] 6747 # HTTP header `Accept` 6748 header_params['Accept'] = self.api_client.\ 6749 select_header_accept(['application/json']) 6750 6751 # Authentication setting 6752 auth_settings = [] 6753 6754 return self.api_client.call_api(resource_path, 'PUT', 6755 path_params, 6756 query_params, 6757 header_params, 6758 body=body_params, 6759 post_params=form_params, 6760 files=local_var_files, 6761 response_type='TabAccountSettings', 6762 auth_settings=auth_settings, 6763 callback=params.get('callback'), 6764 _return_http_data_only=params.get('_return_http_data_only'), 6765 _preload_content=params.get('_preload_content', True), 6766 _request_timeout=params.get('_request_timeout'), 6767 collection_formats=collection_formats) 6768 6769 def update_brand(self, account_id, brand_id, **kwargs): 6770 """ 6771 Updates an existing brand. 6772 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**). 6773 This method makes a synchronous HTTP request by default. To make an 6774 asynchronous HTTP request, please define a `callback` function 6775 to be invoked when receiving the response. 6776 >>> def callback_function(response): 6777 >>> pprint(response) 6778 >>> 6779 >>> thread = api.update_brand(account_id, brand_id, callback=callback_function) 6780 6781 :param callback function: The callback function 6782 for asynchronous request. (optional) 6783 :param str account_id: The external account number (int) or account ID Guid. (required) 6784 :param str brand_id: The unique identifier of a brand. (required) 6785 :param str replace_brand: 6786 :param Brand brand: 6787 :return: Brand 6788 If the method is called asynchronously, 6789 returns the request thread. 6790 """ 6791 kwargs['_return_http_data_only'] = True 6792 if kwargs.get('callback'): 6793 return self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6794 else: 6795 (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6796 return data 6797 6798 def update_brand_with_http_info(self, account_id, brand_id, **kwargs): 6799 """ 6800 Updates an existing brand. 6801 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**). 6802 This method makes a synchronous HTTP request by default. To make an 6803 asynchronous HTTP request, please define a `callback` function 6804 to be invoked when receiving the response. 6805 >>> def callback_function(response): 6806 >>> pprint(response) 6807 >>> 6808 >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function) 6809 6810 :param callback function: The callback function 6811 for asynchronous request. (optional) 6812 :param str account_id: The external account number (int) or account ID Guid. (required) 6813 :param str brand_id: The unique identifier of a brand. (required) 6814 :param str replace_brand: 6815 :param Brand brand: 6816 :return: Brand 6817 If the method is called asynchronously, 6818 returns the request thread. 6819 """ 6820 6821 all_params = ['account_id', 'brand_id', 'replace_brand', 'brand'] 6822 all_params.append('callback') 6823 all_params.append('_return_http_data_only') 6824 all_params.append('_preload_content') 6825 all_params.append('_request_timeout') 6826 6827 params = locals() 6828 for key, val in iteritems(params['kwargs']): 6829 if key not in all_params: 6830 raise TypeError( 6831 "Got an unexpected keyword argument '%s'" 6832 " to method update_brand" % key 6833 ) 6834 params[key] = val 6835 del params['kwargs'] 6836 # verify the required parameter 'account_id' is set 6837 if ('account_id' not in params) or (params['account_id'] is None): 6838 raise ValueError("Missing the required parameter `account_id` when calling `update_brand`") 6839 # verify the required parameter 'brand_id' is set 6840 if ('brand_id' not in params) or (params['brand_id'] is None): 6841 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`") 6842 6843 6844 collection_formats = {} 6845 6846 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 6847 path_params = {} 6848 if 'account_id' in params: 6849 path_params['accountId'] = params['account_id'] 6850 if 'brand_id' in params: 6851 path_params['brandId'] = params['brand_id'] 6852 6853 query_params = {} 6854 if 'replace_brand' in params: 6855 query_params['replace_brand'] = params['replace_brand'] 6856 6857 header_params = {} 6858 6859 form_params = [] 6860 local_var_files = {} 6861 6862 body_params = None 6863 if 'brand' in params: 6864 body_params = params['brand'] 6865 # HTTP header `Accept` 6866 header_params['Accept'] = self.api_client.\ 6867 select_header_accept(['application/json']) 6868 6869 # Authentication setting 6870 auth_settings = [] 6871 6872 return self.api_client.call_api(resource_path, 'PUT', 6873 path_params, 6874 query_params, 6875 header_params, 6876 body=body_params, 6877 post_params=form_params, 6878 files=local_var_files, 6879 response_type='Brand', 6880 auth_settings=auth_settings, 6881 callback=params.get('callback'), 6882 _return_http_data_only=params.get('_return_http_data_only'), 6883 _preload_content=params.get('_preload_content', True), 6884 _request_timeout=params.get('_request_timeout'), 6885 collection_formats=collection_formats) 6886 6887 def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6888 """ 6889 Put one branding logo. 6890 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**). 6891 This method makes a synchronous HTTP request by default. To make an 6892 asynchronous HTTP request, please define a `callback` function 6893 to be invoked when receiving the response. 6894 >>> def callback_function(response): 6895 >>> pprint(response) 6896 >>> 6897 >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6898 6899 :param callback function: The callback function 6900 for asynchronous request. (optional) 6901 :param str account_id: The external account number (int) or account ID GUID. (required) 6902 :param str brand_id: The ID of the brand. (required) 6903 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6904 :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) 6905 :return: None 6906 If the method is called asynchronously, 6907 returns the request thread. 6908 """ 6909 kwargs['_return_http_data_only'] = True 6910 if kwargs.get('callback'): 6911 return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6912 else: 6913 (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6914 return data 6915 6916 def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6917 """ 6918 Put one branding logo. 6919 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**). 6920 This method makes a synchronous HTTP request by default. To make an 6921 asynchronous HTTP request, please define a `callback` function 6922 to be invoked when receiving the response. 6923 >>> def callback_function(response): 6924 >>> pprint(response) 6925 >>> 6926 >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6927 6928 :param callback function: The callback function 6929 for asynchronous request. (optional) 6930 :param str account_id: The external account number (int) or account ID GUID. (required) 6931 :param str brand_id: The ID of the brand. (required) 6932 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6933 :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) 6934 :return: None 6935 If the method is called asynchronously, 6936 returns the request thread. 6937 """ 6938 6939 all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes'] 6940 all_params.append('callback') 6941 all_params.append('_return_http_data_only') 6942 all_params.append('_preload_content') 6943 all_params.append('_request_timeout') 6944 6945 params = locals() 6946 for key, val in iteritems(params['kwargs']): 6947 if key not in all_params: 6948 raise TypeError( 6949 "Got an unexpected keyword argument '%s'" 6950 " to method update_brand_logo_by_type" % key 6951 ) 6952 params[key] = val 6953 del params['kwargs'] 6954 # verify the required parameter 'account_id' is set 6955 if ('account_id' not in params) or (params['account_id'] is None): 6956 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`") 6957 # verify the required parameter 'brand_id' is set 6958 if ('brand_id' not in params) or (params['brand_id'] is None): 6959 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`") 6960 # verify the required parameter 'logo_type' is set 6961 if ('logo_type' not in params) or (params['logo_type'] is None): 6962 raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`") 6963 # verify the required parameter 'logo_file_bytes' is set 6964 if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None): 6965 raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`") 6966 6967 6968 collection_formats = {} 6969 6970 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 6971 path_params = {} 6972 if 'account_id' in params: 6973 path_params['accountId'] = params['account_id'] 6974 if 'brand_id' in params: 6975 path_params['brandId'] = params['brand_id'] 6976 if 'logo_type' in params: 6977 path_params['logoType'] = params['logo_type'] 6978 6979 query_params = {} 6980 6981 header_params = {} 6982 6983 form_params = [] 6984 local_var_files = {} 6985 6986 body_params = None 6987 if 'logo_file_bytes' in params: 6988 body_params = params['logo_file_bytes'] 6989 # HTTP header `Accept` 6990 header_params['Accept'] = self.api_client.\ 6991 select_header_accept(['application/json']) 6992 6993 # HTTP header `Content-Type` 6994 header_params['Content-Type'] = self.api_client.\ 6995 select_header_content_type(['image/png']) 6996 6997 # Authentication setting 6998 auth_settings = [] 6999 7000 return self.api_client.call_api(resource_path, 'PUT', 7001 path_params, 7002 query_params, 7003 header_params, 7004 body=body_params, 7005 post_params=form_params, 7006 files=local_var_files, 7007 response_type=None, 7008 auth_settings=auth_settings, 7009 callback=params.get('callback'), 7010 _return_http_data_only=params.get('_return_http_data_only'), 7011 _preload_content=params.get('_preload_content', True), 7012 _request_timeout=params.get('_request_timeout'), 7013 collection_formats=collection_formats) 7014 7015 def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7016 """ 7017 Uploads a branding resource file. 7018 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. 7019 This method makes a synchronous HTTP request by default. To make an 7020 asynchronous HTTP request, please define a `callback` function 7021 to be invoked when receiving the response. 7022 >>> def callback_function(response): 7023 >>> pprint(response) 7024 >>> 7025 >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7026 7027 :param callback function: The callback function 7028 for asynchronous request. (optional) 7029 :param str account_id: The external account number (int) or account ID GUID. (required) 7030 :param str brand_id: The ID of the brand. (required) 7031 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7032 :param file file_xml: Brand resource XML file. (required) 7033 :return: BrandResources 7034 If the method is called asynchronously, 7035 returns the request thread. 7036 """ 7037 kwargs['_return_http_data_only'] = True 7038 if kwargs.get('callback'): 7039 return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7040 else: 7041 (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7042 return data 7043 7044 def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7045 """ 7046 Uploads a branding resource file. 7047 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. 7048 This method makes a synchronous HTTP request by default. To make an 7049 asynchronous HTTP request, please define a `callback` function 7050 to be invoked when receiving the response. 7051 >>> def callback_function(response): 7052 >>> pprint(response) 7053 >>> 7054 >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7055 7056 :param callback function: The callback function 7057 for asynchronous request. (optional) 7058 :param str account_id: The external account number (int) or account ID GUID. (required) 7059 :param str brand_id: The ID of the brand. (required) 7060 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7061 :param file file_xml: Brand resource XML file. (required) 7062 :return: BrandResources 7063 If the method is called asynchronously, 7064 returns the request thread. 7065 """ 7066 7067 all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml'] 7068 all_params.append('callback') 7069 all_params.append('_return_http_data_only') 7070 all_params.append('_preload_content') 7071 all_params.append('_request_timeout') 7072 7073 params = locals() 7074 for key, val in iteritems(params['kwargs']): 7075 if key not in all_params: 7076 raise TypeError( 7077 "Got an unexpected keyword argument '%s'" 7078 " to method update_brand_resources_by_content_type" % key 7079 ) 7080 params[key] = val 7081 del params['kwargs'] 7082 # verify the required parameter 'account_id' is set 7083 if ('account_id' not in params) or (params['account_id'] is None): 7084 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`") 7085 # verify the required parameter 'brand_id' is set 7086 if ('brand_id' not in params) or (params['brand_id'] is None): 7087 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`") 7088 # verify the required parameter 'resource_content_type' is set 7089 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 7090 raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`") 7091 # verify the required parameter 'file_xml' is set 7092 if ('file_xml' not in params) or (params['file_xml'] is None): 7093 raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`") 7094 7095 7096 collection_formats = {} 7097 7098 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 7099 path_params = {} 7100 if 'account_id' in params: 7101 path_params['accountId'] = params['account_id'] 7102 if 'brand_id' in params: 7103 path_params['brandId'] = params['brand_id'] 7104 if 'resource_content_type' in params: 7105 path_params['resourceContentType'] = params['resource_content_type'] 7106 7107 query_params = {} 7108 7109 header_params = {} 7110 7111 form_params = [] 7112 local_var_files = {} 7113 if 'file_xml' in params: 7114 local_var_files['file.xml'] = params['file_xml'] 7115 7116 body_params = None 7117 # HTTP header `Accept` 7118 header_params['Accept'] = self.api_client.\ 7119 select_header_accept(['application/json']) 7120 7121 # HTTP header `Content-Type` 7122 header_params['Content-Type'] = self.api_client.\ 7123 select_header_content_type(['multipart/form-data']) 7124 7125 # Authentication setting 7126 auth_settings = [] 7127 7128 return self.api_client.call_api(resource_path, 'PUT', 7129 path_params, 7130 query_params, 7131 header_params, 7132 body=body_params, 7133 post_params=form_params, 7134 files=local_var_files, 7135 response_type='BrandResources', 7136 auth_settings=auth_settings, 7137 callback=params.get('callback'), 7138 _return_http_data_only=params.get('_return_http_data_only'), 7139 _preload_content=params.get('_preload_content', True), 7140 _request_timeout=params.get('_request_timeout'), 7141 collection_formats=collection_formats) 7142 7143 def update_consumer_disclosure(self, account_id, lang_code, **kwargs): 7144 """ 7145 Update Consumer Disclosure. 7146 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. 7147 This method makes a synchronous HTTP request by default. To make an 7148 asynchronous HTTP request, please define a `callback` function 7149 to be invoked when receiving the response. 7150 >>> def callback_function(response): 7151 >>> pprint(response) 7152 >>> 7153 >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function) 7154 7155 :param callback function: The callback function 7156 for asynchronous request. (optional) 7157 :param str account_id: The external account number (int) or account ID Guid. (required) 7158 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 7159 :param str include_metadata: 7160 :param ConsumerDisclosure consumer_disclosure: 7161 :return: ConsumerDisclosure 7162 If the method is called asynchronously, 7163 returns the request thread. 7164 """ 7165 kwargs['_return_http_data_only'] = True 7166 if kwargs.get('callback'): 7167 return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7168 else: 7169 (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7170 return data 7171 7172 def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 7173 """ 7174 Update Consumer Disclosure. 7175 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. 7176 This method makes a synchronous HTTP request by default. To make an 7177 asynchronous HTTP request, please define a `callback` function 7178 to be invoked when receiving the response. 7179 >>> def callback_function(response): 7180 >>> pprint(response) 7181 >>> 7182 >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 7183 7184 :param callback function: The callback function 7185 for asynchronous request. (optional) 7186 :param str account_id: The external account number (int) or account ID Guid. (required) 7187 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 7188 :param str include_metadata: 7189 :param ConsumerDisclosure consumer_disclosure: 7190 :return: ConsumerDisclosure 7191 If the method is called asynchronously, 7192 returns the request thread. 7193 """ 7194 7195 all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure'] 7196 all_params.append('callback') 7197 all_params.append('_return_http_data_only') 7198 all_params.append('_preload_content') 7199 all_params.append('_request_timeout') 7200 7201 params = locals() 7202 for key, val in iteritems(params['kwargs']): 7203 if key not in all_params: 7204 raise TypeError( 7205 "Got an unexpected keyword argument '%s'" 7206 " to method update_consumer_disclosure" % key 7207 ) 7208 params[key] = val 7209 del params['kwargs'] 7210 # verify the required parameter 'account_id' is set 7211 if ('account_id' not in params) or (params['account_id'] is None): 7212 raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`") 7213 # verify the required parameter 'lang_code' is set 7214 if ('lang_code' not in params) or (params['lang_code'] is None): 7215 raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`") 7216 7217 7218 collection_formats = {} 7219 7220 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 7221 path_params = {} 7222 if 'account_id' in params: 7223 path_params['accountId'] = params['account_id'] 7224 if 'lang_code' in params: 7225 path_params['langCode'] = params['lang_code'] 7226 7227 query_params = {} 7228 if 'include_metadata' in params: 7229 query_params['include_metadata'] = params['include_metadata'] 7230 7231 header_params = {} 7232 7233 form_params = [] 7234 local_var_files = {} 7235 7236 body_params = None 7237 if 'consumer_disclosure' in params: 7238 body_params = params['consumer_disclosure'] 7239 # HTTP header `Accept` 7240 header_params['Accept'] = self.api_client.\ 7241 select_header_accept(['application/json']) 7242 7243 # Authentication setting 7244 auth_settings = [] 7245 7246 return self.api_client.call_api(resource_path, 'PUT', 7247 path_params, 7248 query_params, 7249 header_params, 7250 body=body_params, 7251 post_params=form_params, 7252 files=local_var_files, 7253 response_type='ConsumerDisclosure', 7254 auth_settings=auth_settings, 7255 callback=params.get('callback'), 7256 _return_http_data_only=params.get('_return_http_data_only'), 7257 _preload_content=params.get('_preload_content', True), 7258 _request_timeout=params.get('_request_timeout'), 7259 collection_formats=collection_formats) 7260 7261 def update_custom_field(self, account_id, custom_field_id, **kwargs): 7262 """ 7263 Updates an existing account custom field. 7264 This method updates an existing account custom field. 7265 This method makes a synchronous HTTP request by default. To make an 7266 asynchronous HTTP request, please define a `callback` function 7267 to be invoked when receiving the response. 7268 >>> def callback_function(response): 7269 >>> pprint(response) 7270 >>> 7271 >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function) 7272 7273 :param callback function: The callback function 7274 for asynchronous request. (optional) 7275 :param str account_id: The external account number (int) or account ID Guid. (required) 7276 :param str custom_field_id: (required) 7277 :param str apply_to_templates: 7278 :param CustomField custom_field: 7279 :return: CustomFields 7280 If the method is called asynchronously, 7281 returns the request thread. 7282 """ 7283 kwargs['_return_http_data_only'] = True 7284 if kwargs.get('callback'): 7285 return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7286 else: 7287 (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7288 return data 7289 7290 def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 7291 """ 7292 Updates an existing account custom field. 7293 This method updates an existing account custom field. 7294 This method makes a synchronous HTTP request by default. To make an 7295 asynchronous HTTP request, please define a `callback` function 7296 to be invoked when receiving the response. 7297 >>> def callback_function(response): 7298 >>> pprint(response) 7299 >>> 7300 >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 7301 7302 :param callback function: The callback function 7303 for asynchronous request. (optional) 7304 :param str account_id: The external account number (int) or account ID Guid. (required) 7305 :param str custom_field_id: (required) 7306 :param str apply_to_templates: 7307 :param CustomField custom_field: 7308 :return: CustomFields 7309 If the method is called asynchronously, 7310 returns the request thread. 7311 """ 7312 7313 all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field'] 7314 all_params.append('callback') 7315 all_params.append('_return_http_data_only') 7316 all_params.append('_preload_content') 7317 all_params.append('_request_timeout') 7318 7319 params = locals() 7320 for key, val in iteritems(params['kwargs']): 7321 if key not in all_params: 7322 raise TypeError( 7323 "Got an unexpected keyword argument '%s'" 7324 " to method update_custom_field" % key 7325 ) 7326 params[key] = val 7327 del params['kwargs'] 7328 # verify the required parameter 'account_id' is set 7329 if ('account_id' not in params) or (params['account_id'] is None): 7330 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`") 7331 # verify the required parameter 'custom_field_id' is set 7332 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 7333 raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`") 7334 7335 7336 collection_formats = {} 7337 7338 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 7339 path_params = {} 7340 if 'account_id' in params: 7341 path_params['accountId'] = params['account_id'] 7342 if 'custom_field_id' in params: 7343 path_params['customFieldId'] = params['custom_field_id'] 7344 7345 query_params = {} 7346 if 'apply_to_templates' in params: 7347 query_params['apply_to_templates'] = params['apply_to_templates'] 7348 7349 header_params = {} 7350 7351 form_params = [] 7352 local_var_files = {} 7353 7354 body_params = None 7355 if 'custom_field' in params: 7356 body_params = params['custom_field'] 7357 # HTTP header `Accept` 7358 header_params['Accept'] = self.api_client.\ 7359 select_header_accept(['application/json']) 7360 7361 # Authentication setting 7362 auth_settings = [] 7363 7364 return self.api_client.call_api(resource_path, 'PUT', 7365 path_params, 7366 query_params, 7367 header_params, 7368 body=body_params, 7369 post_params=form_params, 7370 files=local_var_files, 7371 response_type='CustomFields', 7372 auth_settings=auth_settings, 7373 callback=params.get('callback'), 7374 _return_http_data_only=params.get('_return_http_data_only'), 7375 _preload_content=params.get('_preload_content', True), 7376 _request_timeout=params.get('_request_timeout'), 7377 collection_formats=collection_formats) 7378 7379 def update_e_note_configuration(self, account_id, **kwargs): 7380 """ 7381 Updates configuration information for the eNote eOriginal integration. 7382 7383 This method makes a synchronous HTTP request by default. To make an 7384 asynchronous HTTP request, please define a `callback` function 7385 to be invoked when receiving the response. 7386 >>> def callback_function(response): 7387 >>> pprint(response) 7388 >>> 7389 >>> thread = api.update_e_note_configuration(account_id, callback=callback_function) 7390 7391 :param callback function: The callback function 7392 for asynchronous request. (optional) 7393 :param str account_id: The external account number (int) or account ID Guid. (required) 7394 :param ENoteConfiguration e_note_configuration: 7395 :return: ENoteConfiguration 7396 If the method is called asynchronously, 7397 returns the request thread. 7398 """ 7399 kwargs['_return_http_data_only'] = True 7400 if kwargs.get('callback'): 7401 return self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7402 else: 7403 (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7404 return data 7405 7406 def update_e_note_configuration_with_http_info(self, account_id, **kwargs): 7407 """ 7408 Updates configuration information for the eNote eOriginal integration. 7409 7410 This method makes a synchronous HTTP request by default. To make an 7411 asynchronous HTTP request, please define a `callback` function 7412 to be invoked when receiving the response. 7413 >>> def callback_function(response): 7414 >>> pprint(response) 7415 >>> 7416 >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function) 7417 7418 :param callback function: The callback function 7419 for asynchronous request. (optional) 7420 :param str account_id: The external account number (int) or account ID Guid. (required) 7421 :param ENoteConfiguration e_note_configuration: 7422 :return: ENoteConfiguration 7423 If the method is called asynchronously, 7424 returns the request thread. 7425 """ 7426 7427 all_params = ['account_id', 'e_note_configuration'] 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_e_note_configuration" % 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_e_note_configuration`") 7445 7446 7447 collection_formats = {} 7448 7449 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 7450 path_params = {} 7451 if 'account_id' in params: 7452 path_params['accountId'] = params['account_id'] 7453 7454 query_params = {} 7455 7456 header_params = {} 7457 7458 form_params = [] 7459 local_var_files = {} 7460 7461 body_params = None 7462 if 'e_note_configuration' in params: 7463 body_params = params['e_note_configuration'] 7464 # HTTP header `Accept` 7465 header_params['Accept'] = self.api_client.\ 7466 select_header_accept(['application/json']) 7467 7468 # Authentication setting 7469 auth_settings = [] 7470 7471 return self.api_client.call_api(resource_path, 'PUT', 7472 path_params, 7473 query_params, 7474 header_params, 7475 body=body_params, 7476 post_params=form_params, 7477 files=local_var_files, 7478 response_type='ENoteConfiguration', 7479 auth_settings=auth_settings, 7480 callback=params.get('callback'), 7481 _return_http_data_only=params.get('_return_http_data_only'), 7482 _preload_content=params.get('_preload_content', True), 7483 _request_timeout=params.get('_request_timeout'), 7484 collection_formats=collection_formats) 7485 7486 def update_envelope_purge_configuration(self, account_id, **kwargs): 7487 """ 7488 Updates envelope purge configuration. 7489 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). 7490 This method makes a synchronous HTTP request by default. To make an 7491 asynchronous HTTP request, please define a `callback` function 7492 to be invoked when receiving the response. 7493 >>> def callback_function(response): 7494 >>> pprint(response) 7495 >>> 7496 >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function) 7497 7498 :param callback function: The callback function 7499 for asynchronous request. (optional) 7500 :param str account_id: The external account number (int) or account ID Guid. (required) 7501 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7502 :return: EnvelopePurgeConfiguration 7503 If the method is called asynchronously, 7504 returns the request thread. 7505 """ 7506 kwargs['_return_http_data_only'] = True 7507 if kwargs.get('callback'): 7508 return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7509 else: 7510 (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7511 return data 7512 7513 def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 7514 """ 7515 Updates envelope purge configuration. 7516 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). 7517 This method makes a synchronous HTTP request by default. To make an 7518 asynchronous HTTP request, please define a `callback` function 7519 to be invoked when receiving the response. 7520 >>> def callback_function(response): 7521 >>> pprint(response) 7522 >>> 7523 >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 7524 7525 :param callback function: The callback function 7526 for asynchronous request. (optional) 7527 :param str account_id: The external account number (int) or account ID Guid. (required) 7528 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7529 :return: EnvelopePurgeConfiguration 7530 If the method is called asynchronously, 7531 returns the request thread. 7532 """ 7533 7534 all_params = ['account_id', 'envelope_purge_configuration'] 7535 all_params.append('callback') 7536 all_params.append('_return_http_data_only') 7537 all_params.append('_preload_content') 7538 all_params.append('_request_timeout') 7539 7540 params = locals() 7541 for key, val in iteritems(params['kwargs']): 7542 if key not in all_params: 7543 raise TypeError( 7544 "Got an unexpected keyword argument '%s'" 7545 " to method update_envelope_purge_configuration" % key 7546 ) 7547 params[key] = val 7548 del params['kwargs'] 7549 # verify the required parameter 'account_id' is set 7550 if ('account_id' not in params) or (params['account_id'] is None): 7551 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`") 7552 7553 7554 collection_formats = {} 7555 7556 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 7557 path_params = {} 7558 if 'account_id' in params: 7559 path_params['accountId'] = params['account_id'] 7560 7561 query_params = {} 7562 7563 header_params = {} 7564 7565 form_params = [] 7566 local_var_files = {} 7567 7568 body_params = None 7569 if 'envelope_purge_configuration' in params: 7570 body_params = params['envelope_purge_configuration'] 7571 # HTTP header `Accept` 7572 header_params['Accept'] = self.api_client.\ 7573 select_header_accept(['application/json']) 7574 7575 # Authentication setting 7576 auth_settings = [] 7577 7578 return self.api_client.call_api(resource_path, 'PUT', 7579 path_params, 7580 query_params, 7581 header_params, 7582 body=body_params, 7583 post_params=form_params, 7584 files=local_var_files, 7585 response_type='EnvelopePurgeConfiguration', 7586 auth_settings=auth_settings, 7587 callback=params.get('callback'), 7588 _return_http_data_only=params.get('_return_http_data_only'), 7589 _preload_content=params.get('_preload_content', True), 7590 _request_timeout=params.get('_request_timeout'), 7591 collection_formats=collection_formats) 7592 7593 def update_favorite_template(self, account_id, **kwargs): 7594 """ 7595 Favorites a template 7596 7597 This method makes a synchronous HTTP request by default. To make an 7598 asynchronous HTTP request, please define a `callback` function 7599 to be invoked when receiving the response. 7600 >>> def callback_function(response): 7601 >>> pprint(response) 7602 >>> 7603 >>> thread = api.update_favorite_template(account_id, callback=callback_function) 7604 7605 :param callback function: The callback function 7606 for asynchronous request. (optional) 7607 :param str account_id: The external account number (int) or account ID Guid. (required) 7608 :param FavoriteTemplatesInfo favorite_templates_info: 7609 :return: FavoriteTemplatesInfo 7610 If the method is called asynchronously, 7611 returns the request thread. 7612 """ 7613 kwargs['_return_http_data_only'] = True 7614 if kwargs.get('callback'): 7615 return self.update_favorite_template_with_http_info(account_id, **kwargs) 7616 else: 7617 (data) = self.update_favorite_template_with_http_info(account_id, **kwargs) 7618 return data 7619 7620 def update_favorite_template_with_http_info(self, account_id, **kwargs): 7621 """ 7622 Favorites a template 7623 7624 This method makes a synchronous HTTP request by default. To make an 7625 asynchronous HTTP request, please define a `callback` function 7626 to be invoked when receiving the response. 7627 >>> def callback_function(response): 7628 >>> pprint(response) 7629 >>> 7630 >>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function) 7631 7632 :param callback function: The callback function 7633 for asynchronous request. (optional) 7634 :param str account_id: The external account number (int) or account ID Guid. (required) 7635 :param FavoriteTemplatesInfo favorite_templates_info: 7636 :return: FavoriteTemplatesInfo 7637 If the method is called asynchronously, 7638 returns the request thread. 7639 """ 7640 7641 all_params = ['account_id', 'favorite_templates_info'] 7642 all_params.append('callback') 7643 all_params.append('_return_http_data_only') 7644 all_params.append('_preload_content') 7645 all_params.append('_request_timeout') 7646 7647 params = locals() 7648 for key, val in iteritems(params['kwargs']): 7649 if key not in all_params: 7650 raise TypeError( 7651 "Got an unexpected keyword argument '%s'" 7652 " to method update_favorite_template" % key 7653 ) 7654 params[key] = val 7655 del params['kwargs'] 7656 # verify the required parameter 'account_id' is set 7657 if ('account_id' not in params) or (params['account_id'] is None): 7658 raise ValueError("Missing the required parameter `account_id` when calling `update_favorite_template`") 7659 7660 7661 collection_formats = {} 7662 7663 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 7664 path_params = {} 7665 if 'account_id' in params: 7666 path_params['accountId'] = params['account_id'] 7667 7668 query_params = {} 7669 7670 header_params = {} 7671 7672 form_params = [] 7673 local_var_files = {} 7674 7675 body_params = None 7676 if 'favorite_templates_info' in params: 7677 body_params = params['favorite_templates_info'] 7678 # HTTP header `Accept` 7679 header_params['Accept'] = self.api_client.\ 7680 select_header_accept(['application/json']) 7681 7682 # Authentication setting 7683 auth_settings = [] 7684 7685 return self.api_client.call_api(resource_path, 'PUT', 7686 path_params, 7687 query_params, 7688 header_params, 7689 body=body_params, 7690 post_params=form_params, 7691 files=local_var_files, 7692 response_type='FavoriteTemplatesInfo', 7693 auth_settings=auth_settings, 7694 callback=params.get('callback'), 7695 _return_http_data_only=params.get('_return_http_data_only'), 7696 _preload_content=params.get('_preload_content', True), 7697 _request_timeout=params.get('_request_timeout'), 7698 collection_formats=collection_formats) 7699 7700 def update_notification_defaults(self, account_id, **kwargs): 7701 """ 7702 Updates default user level settings for a specified account 7703 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7704 This method makes a synchronous HTTP request by default. To make an 7705 asynchronous HTTP request, please define a `callback` function 7706 to be invoked when receiving the response. 7707 >>> def callback_function(response): 7708 >>> pprint(response) 7709 >>> 7710 >>> thread = api.update_notification_defaults(account_id, callback=callback_function) 7711 7712 :param callback function: The callback function 7713 for asynchronous request. (optional) 7714 :param str account_id: The external account number (int) or account ID Guid. (required) 7715 :param NotificationDefaults notification_defaults: 7716 :return: NotificationDefaults 7717 If the method is called asynchronously, 7718 returns the request thread. 7719 """ 7720 kwargs['_return_http_data_only'] = True 7721 if kwargs.get('callback'): 7722 return self.update_notification_defaults_with_http_info(account_id, **kwargs) 7723 else: 7724 (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs) 7725 return data 7726 7727 def update_notification_defaults_with_http_info(self, account_id, **kwargs): 7728 """ 7729 Updates default user level settings for a specified account 7730 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7731 This method makes a synchronous HTTP request by default. To make an 7732 asynchronous HTTP request, please define a `callback` function 7733 to be invoked when receiving the response. 7734 >>> def callback_function(response): 7735 >>> pprint(response) 7736 >>> 7737 >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function) 7738 7739 :param callback function: The callback function 7740 for asynchronous request. (optional) 7741 :param str account_id: The external account number (int) or account ID Guid. (required) 7742 :param NotificationDefaults notification_defaults: 7743 :return: NotificationDefaults 7744 If the method is called asynchronously, 7745 returns the request thread. 7746 """ 7747 7748 all_params = ['account_id', 'notification_defaults'] 7749 all_params.append('callback') 7750 all_params.append('_return_http_data_only') 7751 all_params.append('_preload_content') 7752 all_params.append('_request_timeout') 7753 7754 params = locals() 7755 for key, val in iteritems(params['kwargs']): 7756 if key not in all_params: 7757 raise TypeError( 7758 "Got an unexpected keyword argument '%s'" 7759 " to method update_notification_defaults" % key 7760 ) 7761 params[key] = val 7762 del params['kwargs'] 7763 # verify the required parameter 'account_id' is set 7764 if ('account_id' not in params) or (params['account_id'] is None): 7765 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`") 7766 7767 7768 collection_formats = {} 7769 7770 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 7771 path_params = {} 7772 if 'account_id' in params: 7773 path_params['accountId'] = params['account_id'] 7774 7775 query_params = {} 7776 7777 header_params = {} 7778 7779 form_params = [] 7780 local_var_files = {} 7781 7782 body_params = None 7783 if 'notification_defaults' in params: 7784 body_params = params['notification_defaults'] 7785 # HTTP header `Accept` 7786 header_params['Accept'] = self.api_client.\ 7787 select_header_accept(['application/json']) 7788 7789 # Authentication setting 7790 auth_settings = [] 7791 7792 return self.api_client.call_api(resource_path, 'PUT', 7793 path_params, 7794 query_params, 7795 header_params, 7796 body=body_params, 7797 post_params=form_params, 7798 files=local_var_files, 7799 response_type='NotificationDefaults', 7800 auth_settings=auth_settings, 7801 callback=params.get('callback'), 7802 _return_http_data_only=params.get('_return_http_data_only'), 7803 _preload_content=params.get('_preload_content', True), 7804 _request_timeout=params.get('_request_timeout'), 7805 collection_formats=collection_formats) 7806 7807 def update_password_rules(self, account_id, **kwargs): 7808 """ 7809 Update the password rules 7810 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7811 This method makes a synchronous HTTP request by default. To make an 7812 asynchronous HTTP request, please define a `callback` function 7813 to be invoked when receiving the response. 7814 >>> def callback_function(response): 7815 >>> pprint(response) 7816 >>> 7817 >>> thread = api.update_password_rules(account_id, callback=callback_function) 7818 7819 :param callback function: The callback function 7820 for asynchronous request. (optional) 7821 :param str account_id: The external account number (int) or account ID Guid. (required) 7822 :param AccountPasswordRules account_password_rules: 7823 :return: AccountPasswordRules 7824 If the method is called asynchronously, 7825 returns the request thread. 7826 """ 7827 kwargs['_return_http_data_only'] = True 7828 if kwargs.get('callback'): 7829 return self.update_password_rules_with_http_info(account_id, **kwargs) 7830 else: 7831 (data) = self.update_password_rules_with_http_info(account_id, **kwargs) 7832 return data 7833 7834 def update_password_rules_with_http_info(self, account_id, **kwargs): 7835 """ 7836 Update the password rules 7837 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7838 This method makes a synchronous HTTP request by default. To make an 7839 asynchronous HTTP request, please define a `callback` function 7840 to be invoked when receiving the response. 7841 >>> def callback_function(response): 7842 >>> pprint(response) 7843 >>> 7844 >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function) 7845 7846 :param callback function: The callback function 7847 for asynchronous request. (optional) 7848 :param str account_id: The external account number (int) or account ID Guid. (required) 7849 :param AccountPasswordRules account_password_rules: 7850 :return: AccountPasswordRules 7851 If the method is called asynchronously, 7852 returns the request thread. 7853 """ 7854 7855 all_params = ['account_id', 'account_password_rules'] 7856 all_params.append('callback') 7857 all_params.append('_return_http_data_only') 7858 all_params.append('_preload_content') 7859 all_params.append('_request_timeout') 7860 7861 params = locals() 7862 for key, val in iteritems(params['kwargs']): 7863 if key not in all_params: 7864 raise TypeError( 7865 "Got an unexpected keyword argument '%s'" 7866 " to method update_password_rules" % key 7867 ) 7868 params[key] = val 7869 del params['kwargs'] 7870 # verify the required parameter 'account_id' is set 7871 if ('account_id' not in params) or (params['account_id'] is None): 7872 raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`") 7873 7874 7875 collection_formats = {} 7876 7877 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 7878 path_params = {} 7879 if 'account_id' in params: 7880 path_params['accountId'] = params['account_id'] 7881 7882 query_params = {} 7883 7884 header_params = {} 7885 7886 form_params = [] 7887 local_var_files = {} 7888 7889 body_params = None 7890 if 'account_password_rules' in params: 7891 body_params = params['account_password_rules'] 7892 # HTTP header `Accept` 7893 header_params['Accept'] = self.api_client.\ 7894 select_header_accept(['application/json']) 7895 7896 # Authentication setting 7897 auth_settings = [] 7898 7899 return self.api_client.call_api(resource_path, 'PUT', 7900 path_params, 7901 query_params, 7902 header_params, 7903 body=body_params, 7904 post_params=form_params, 7905 files=local_var_files, 7906 response_type='AccountPasswordRules', 7907 auth_settings=auth_settings, 7908 callback=params.get('callback'), 7909 _return_http_data_only=params.get('_return_http_data_only'), 7910 _preload_content=params.get('_preload_content', True), 7911 _request_timeout=params.get('_request_timeout'), 7912 collection_formats=collection_formats) 7913 7914 def update_permission_profile(self, account_id, permission_profile_id, **kwargs): 7915 """ 7916 Updates a permission profile within the specified account. 7917 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7918 This method makes a synchronous HTTP request by default. To make an 7919 asynchronous HTTP request, please define a `callback` function 7920 to be invoked when receiving the response. 7921 >>> def callback_function(response): 7922 >>> pprint(response) 7923 >>> 7924 >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function) 7925 7926 :param callback function: The callback function 7927 for asynchronous request. (optional) 7928 :param str account_id: The external account number (int) or account ID Guid. (required) 7929 :param str permission_profile_id: (required) 7930 :param str include: 7931 :param PermissionProfile permission_profile: 7932 :return: PermissionProfile 7933 If the method is called asynchronously, 7934 returns the request thread. 7935 """ 7936 kwargs['_return_http_data_only'] = True 7937 if kwargs.get('callback'): 7938 return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7939 else: 7940 (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7941 return data 7942 7943 def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 7944 """ 7945 Updates a permission profile within the specified account. 7946 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7947 This method makes a synchronous HTTP request by default. To make an 7948 asynchronous HTTP request, please define a `callback` function 7949 to be invoked when receiving the response. 7950 >>> def callback_function(response): 7951 >>> pprint(response) 7952 >>> 7953 >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 7954 7955 :param callback function: The callback function 7956 for asynchronous request. (optional) 7957 :param str account_id: The external account number (int) or account ID Guid. (required) 7958 :param str permission_profile_id: (required) 7959 :param str include: 7960 :param PermissionProfile permission_profile: 7961 :return: PermissionProfile 7962 If the method is called asynchronously, 7963 returns the request thread. 7964 """ 7965 7966 all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile'] 7967 all_params.append('callback') 7968 all_params.append('_return_http_data_only') 7969 all_params.append('_preload_content') 7970 all_params.append('_request_timeout') 7971 7972 params = locals() 7973 for key, val in iteritems(params['kwargs']): 7974 if key not in all_params: 7975 raise TypeError( 7976 "Got an unexpected keyword argument '%s'" 7977 " to method update_permission_profile" % key 7978 ) 7979 params[key] = val 7980 del params['kwargs'] 7981 # verify the required parameter 'account_id' is set 7982 if ('account_id' not in params) or (params['account_id'] is None): 7983 raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`") 7984 # verify the required parameter 'permission_profile_id' is set 7985 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 7986 raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`") 7987 7988 7989 collection_formats = {} 7990 7991 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 7992 path_params = {} 7993 if 'account_id' in params: 7994 path_params['accountId'] = params['account_id'] 7995 if 'permission_profile_id' in params: 7996 path_params['permissionProfileId'] = params['permission_profile_id'] 7997 7998 query_params = {} 7999 if 'include' in params: 8000 query_params['include'] = params['include'] 8001 8002 header_params = {} 8003 8004 form_params = [] 8005 local_var_files = {} 8006 8007 body_params = None 8008 if 'permission_profile' in params: 8009 body_params = params['permission_profile'] 8010 # HTTP header `Accept` 8011 header_params['Accept'] = self.api_client.\ 8012 select_header_accept(['application/json']) 8013 8014 # Authentication setting 8015 auth_settings = [] 8016 8017 return self.api_client.call_api(resource_path, 'PUT', 8018 path_params, 8019 query_params, 8020 header_params, 8021 body=body_params, 8022 post_params=form_params, 8023 files=local_var_files, 8024 response_type='PermissionProfile', 8025 auth_settings=auth_settings, 8026 callback=params.get('callback'), 8027 _return_http_data_only=params.get('_return_http_data_only'), 8028 _preload_content=params.get('_preload_content', True), 8029 _request_timeout=params.get('_request_timeout'), 8030 collection_formats=collection_formats) 8031 8032 def update_settings(self, account_id, **kwargs): 8033 """ 8034 Updates the account settings for an account. 8035 Updates the account settings for the specified account. 8036 This method makes a synchronous HTTP request by default. To make an 8037 asynchronous HTTP request, please define a `callback` function 8038 to be invoked when receiving the response. 8039 >>> def callback_function(response): 8040 >>> pprint(response) 8041 >>> 8042 >>> thread = api.update_settings(account_id, callback=callback_function) 8043 8044 :param callback function: The callback function 8045 for asynchronous request. (optional) 8046 :param str account_id: The external account number (int) or account ID Guid. (required) 8047 :param AccountSettingsInformation account_settings_information: 8048 :return: None 8049 If the method is called asynchronously, 8050 returns the request thread. 8051 """ 8052 kwargs['_return_http_data_only'] = True 8053 if kwargs.get('callback'): 8054 return self.update_settings_with_http_info(account_id, **kwargs) 8055 else: 8056 (data) = self.update_settings_with_http_info(account_id, **kwargs) 8057 return data 8058 8059 def update_settings_with_http_info(self, account_id, **kwargs): 8060 """ 8061 Updates the account settings for an account. 8062 Updates the account settings for the specified account. 8063 This method makes a synchronous HTTP request by default. To make an 8064 asynchronous HTTP request, please define a `callback` function 8065 to be invoked when receiving the response. 8066 >>> def callback_function(response): 8067 >>> pprint(response) 8068 >>> 8069 >>> thread = api.update_settings_with_http_info(account_id, callback=callback_function) 8070 8071 :param callback function: The callback function 8072 for asynchronous request. (optional) 8073 :param str account_id: The external account number (int) or account ID Guid. (required) 8074 :param AccountSettingsInformation account_settings_information: 8075 :return: None 8076 If the method is called asynchronously, 8077 returns the request thread. 8078 """ 8079 8080 all_params = ['account_id', 'account_settings_information'] 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_settings" % 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_settings`") 8098 8099 8100 collection_formats = {} 8101 8102 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 8103 path_params = {} 8104 if 'account_id' in params: 8105 path_params['accountId'] = params['account_id'] 8106 8107 query_params = {} 8108 8109 header_params = {} 8110 8111 form_params = [] 8112 local_var_files = {} 8113 8114 body_params = None 8115 if 'account_settings_information' in params: 8116 body_params = params['account_settings_information'] 8117 # HTTP header `Accept` 8118 header_params['Accept'] = self.api_client.\ 8119 select_header_accept(['application/json']) 8120 8121 # Authentication setting 8122 auth_settings = [] 8123 8124 return self.api_client.call_api(resource_path, 'PUT', 8125 path_params, 8126 query_params, 8127 header_params, 8128 body=body_params, 8129 post_params=form_params, 8130 files=local_var_files, 8131 response_type=None, 8132 auth_settings=auth_settings, 8133 callback=params.get('callback'), 8134 _return_http_data_only=params.get('_return_http_data_only'), 8135 _preload_content=params.get('_preload_content', True), 8136 _request_timeout=params.get('_request_timeout'), 8137 collection_formats=collection_formats) 8138 8139 def update_shared_access(self, account_id, **kwargs): 8140 """ 8141 Reserved: Sets the shared access information for users. 8142 Reserved: Sets the shared access information for one or more users. 8143 This method makes a synchronous HTTP request by default. To make an 8144 asynchronous HTTP request, please define a `callback` function 8145 to be invoked when receiving the response. 8146 >>> def callback_function(response): 8147 >>> pprint(response) 8148 >>> 8149 >>> thread = api.update_shared_access(account_id, callback=callback_function) 8150 8151 :param callback function: The callback function 8152 for asynchronous request. (optional) 8153 :param str account_id: The external account number (int) or account ID Guid. (required) 8154 :param str item_type: 8155 :param str preserve_existing_shared_access: 8156 :param str user_ids: 8157 :param AccountSharedAccess account_shared_access: 8158 :return: AccountSharedAccess 8159 If the method is called asynchronously, 8160 returns the request thread. 8161 """ 8162 kwargs['_return_http_data_only'] = True 8163 if kwargs.get('callback'): 8164 return self.update_shared_access_with_http_info(account_id, **kwargs) 8165 else: 8166 (data) = self.update_shared_access_with_http_info(account_id, **kwargs) 8167 return data 8168 8169 def update_shared_access_with_http_info(self, account_id, **kwargs): 8170 """ 8171 Reserved: Sets the shared access information for users. 8172 Reserved: Sets the shared access information for one or more users. 8173 This method makes a synchronous HTTP request by default. To make an 8174 asynchronous HTTP request, please define a `callback` function 8175 to be invoked when receiving the response. 8176 >>> def callback_function(response): 8177 >>> pprint(response) 8178 >>> 8179 >>> thread = api.update_shared_access_with_http_info(account_id, callback=callback_function) 8180 8181 :param callback function: The callback function 8182 for asynchronous request. (optional) 8183 :param str account_id: The external account number (int) or account ID Guid. (required) 8184 :param str item_type: 8185 :param str preserve_existing_shared_access: 8186 :param str user_ids: 8187 :param AccountSharedAccess account_shared_access: 8188 :return: AccountSharedAccess 8189 If the method is called asynchronously, 8190 returns the request thread. 8191 """ 8192 8193 all_params = ['account_id', 'item_type', 'preserve_existing_shared_access', 'user_ids', 'account_shared_access'] 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_shared_access" % 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_shared_access`") 8211 8212 8213 collection_formats = {} 8214 8215 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 8216 path_params = {} 8217 if 'account_id' in params: 8218 path_params['accountId'] = params['account_id'] 8219 8220 query_params = {} 8221 if 'item_type' in params: 8222 query_params['item_type'] = params['item_type'] 8223 if 'preserve_existing_shared_access' in params: 8224 query_params['preserve_existing_shared_access'] = params['preserve_existing_shared_access'] 8225 if 'user_ids' in params: 8226 query_params['user_ids'] = params['user_ids'] 8227 8228 header_params = {} 8229 8230 form_params = [] 8231 local_var_files = {} 8232 8233 body_params = None 8234 if 'account_shared_access' in params: 8235 body_params = params['account_shared_access'] 8236 # HTTP header `Accept` 8237 header_params['Accept'] = self.api_client.\ 8238 select_header_accept(['application/json']) 8239 8240 # Authentication setting 8241 auth_settings = [] 8242 8243 return self.api_client.call_api(resource_path, 'PUT', 8244 path_params, 8245 query_params, 8246 header_params, 8247 body=body_params, 8248 post_params=form_params, 8249 files=local_var_files, 8250 response_type='AccountSharedAccess', 8251 auth_settings=auth_settings, 8252 callback=params.get('callback'), 8253 _return_http_data_only=params.get('_return_http_data_only'), 8254 _preload_content=params.get('_preload_content', True), 8255 _request_timeout=params.get('_request_timeout'), 8256 collection_formats=collection_formats) 8257 8258 def update_user_authorization(self, account_id, authorization_id, user_id, **kwargs): 8259 """ 8260 Updates the user authorization 8261 This method makes a synchronous HTTP request by default. To make an 8262 asynchronous HTTP request, please define a `callback` function 8263 to be invoked when receiving the response. 8264 >>> def callback_function(response): 8265 >>> pprint(response) 8266 >>> 8267 >>> thread = api.update_user_authorization(account_id, authorization_id, user_id, callback=callback_function) 8268 8269 :param callback function: The callback function 8270 for asynchronous request. (optional) 8271 :param str account_id: The external account number (int) or account ID Guid. (required) 8272 :param str authorization_id: (required) 8273 :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) 8274 :param UserAuthorizationUpdateRequest user_authorization_update_request: 8275 :return: UserAuthorization 8276 If the method is called asynchronously, 8277 returns the request thread. 8278 """ 8279 kwargs['_return_http_data_only'] = True 8280 if kwargs.get('callback'): 8281 return self.update_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 8282 else: 8283 (data) = self.update_user_authorization_with_http_info(account_id, authorization_id, user_id, **kwargs) 8284 return data 8285 8286 def update_user_authorization_with_http_info(self, account_id, authorization_id, user_id, **kwargs): 8287 """ 8288 Updates the user authorization 8289 This method makes a synchronous HTTP request by default. To make an 8290 asynchronous HTTP request, please define a `callback` function 8291 to be invoked when receiving the response. 8292 >>> def callback_function(response): 8293 >>> pprint(response) 8294 >>> 8295 >>> thread = api.update_user_authorization_with_http_info(account_id, authorization_id, user_id, callback=callback_function) 8296 8297 :param callback function: The callback function 8298 for asynchronous request. (optional) 8299 :param str account_id: The external account number (int) or account ID Guid. (required) 8300 :param str authorization_id: (required) 8301 :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) 8302 :param UserAuthorizationUpdateRequest user_authorization_update_request: 8303 :return: UserAuthorization 8304 If the method is called asynchronously, 8305 returns the request thread. 8306 """ 8307 8308 all_params = ['account_id', 'authorization_id', 'user_id', 'user_authorization_update_request'] 8309 all_params.append('callback') 8310 all_params.append('_return_http_data_only') 8311 all_params.append('_preload_content') 8312 all_params.append('_request_timeout') 8313 8314 params = locals() 8315 for key, val in iteritems(params['kwargs']): 8316 if key not in all_params: 8317 raise TypeError( 8318 "Got an unexpected keyword argument '%s'" 8319 " to method update_user_authorization" % key 8320 ) 8321 params[key] = val 8322 del params['kwargs'] 8323 # verify the required parameter 'account_id' is set 8324 if ('account_id' not in params) or (params['account_id'] is None): 8325 raise ValueError("Missing the required parameter `account_id` when calling `update_user_authorization`") 8326 # verify the required parameter 'authorization_id' is set 8327 if ('authorization_id' not in params) or (params['authorization_id'] is None): 8328 raise ValueError("Missing the required parameter `authorization_id` when calling `update_user_authorization`") 8329 # verify the required parameter 'user_id' is set 8330 if ('user_id' not in params) or (params['user_id'] is None): 8331 raise ValueError("Missing the required parameter `user_id` when calling `update_user_authorization`") 8332 8333 8334 collection_formats = {} 8335 8336 resource_path = '/v2.1/accounts/{accountId}/users/{userId}/authorization/{authorizationId}'.replace('{format}', 'json') 8337 path_params = {} 8338 if 'account_id' in params: 8339 path_params['accountId'] = params['account_id'] 8340 if 'authorization_id' in params: 8341 path_params['authorizationId'] = params['authorization_id'] 8342 if 'user_id' in params: 8343 path_params['userId'] = params['user_id'] 8344 8345 query_params = {} 8346 8347 header_params = {} 8348 8349 form_params = [] 8350 local_var_files = {} 8351 8352 body_params = None 8353 if 'user_authorization_update_request' in params: 8354 body_params = params['user_authorization_update_request'] 8355 # HTTP header `Accept` 8356 header_params['Accept'] = self.api_client.\ 8357 select_header_accept(['application/json']) 8358 8359 # Authentication setting 8360 auth_settings = [] 8361 8362 return self.api_client.call_api(resource_path, 'PUT', 8363 path_params, 8364 query_params, 8365 header_params, 8366 body=body_params, 8367 post_params=form_params, 8368 files=local_var_files, 8369 response_type='UserAuthorization', 8370 auth_settings=auth_settings, 8371 callback=params.get('callback'), 8372 _return_http_data_only=params.get('_return_http_data_only'), 8373 _preload_content=params.get('_preload_content', True), 8374 _request_timeout=params.get('_request_timeout'), 8375 collection_formats=collection_formats) 8376 8377 def update_watermark(self, account_id, **kwargs): 8378 """ 8379 Update watermark information. 8380 8381 This method makes a synchronous HTTP request by default. To make an 8382 asynchronous HTTP request, please define a `callback` function 8383 to be invoked when receiving the response. 8384 >>> def callback_function(response): 8385 >>> pprint(response) 8386 >>> 8387 >>> thread = api.update_watermark(account_id, callback=callback_function) 8388 8389 :param callback function: The callback function 8390 for asynchronous request. (optional) 8391 :param str account_id: The external account number (int) or account ID Guid. (required) 8392 :param Watermark watermark: 8393 :return: Watermark 8394 If the method is called asynchronously, 8395 returns the request thread. 8396 """ 8397 kwargs['_return_http_data_only'] = True 8398 if kwargs.get('callback'): 8399 return self.update_watermark_with_http_info(account_id, **kwargs) 8400 else: 8401 (data) = self.update_watermark_with_http_info(account_id, **kwargs) 8402 return data 8403 8404 def update_watermark_with_http_info(self, account_id, **kwargs): 8405 """ 8406 Update watermark information. 8407 8408 This method makes a synchronous HTTP request by default. To make an 8409 asynchronous HTTP request, please define a `callback` function 8410 to be invoked when receiving the response. 8411 >>> def callback_function(response): 8412 >>> pprint(response) 8413 >>> 8414 >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function) 8415 8416 :param callback function: The callback function 8417 for asynchronous request. (optional) 8418 :param str account_id: The external account number (int) or account ID Guid. (required) 8419 :param Watermark watermark: 8420 :return: Watermark 8421 If the method is called asynchronously, 8422 returns the request thread. 8423 """ 8424 8425 all_params = ['account_id', 'watermark'] 8426 all_params.append('callback') 8427 all_params.append('_return_http_data_only') 8428 all_params.append('_preload_content') 8429 all_params.append('_request_timeout') 8430 8431 params = locals() 8432 for key, val in iteritems(params['kwargs']): 8433 if key not in all_params: 8434 raise TypeError( 8435 "Got an unexpected keyword argument '%s'" 8436 " to method update_watermark" % key 8437 ) 8438 params[key] = val 8439 del params['kwargs'] 8440 # verify the required parameter 'account_id' is set 8441 if ('account_id' not in params) or (params['account_id'] is None): 8442 raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`") 8443 8444 8445 collection_formats = {} 8446 8447 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 8448 path_params = {} 8449 if 'account_id' in params: 8450 path_params['accountId'] = params['account_id'] 8451 8452 query_params = {} 8453 8454 header_params = {} 8455 8456 form_params = [] 8457 local_var_files = {} 8458 8459 body_params = None 8460 if 'watermark' in params: 8461 body_params = params['watermark'] 8462 # HTTP header `Accept` 8463 header_params['Accept'] = self.api_client.\ 8464 select_header_accept(['application/json']) 8465 8466 # Authentication setting 8467 auth_settings = [] 8468 8469 return self.api_client.call_api(resource_path, 'PUT', 8470 path_params, 8471 query_params, 8472 header_params, 8473 body=body_params, 8474 post_params=form_params, 8475 files=local_var_files, 8476 response_type='Watermark', 8477 auth_settings=auth_settings, 8478 callback=params.get('callback'), 8479 _return_http_data_only=params.get('_return_http_data_only'), 8480 _preload_content=params.get('_preload_content', True), 8481 _request_timeout=params.get('_request_timeout'), 8482 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 :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
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)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_with_http_info(self, account_id, **kwargs)
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 :return: None 854 If the method is called asynchronously, 855 returns the request thread. 856 """ 857 858 all_params = ['account_id'] 859 all_params.append('callback') 860 all_params.append('_return_http_data_only') 861 all_params.append('_preload_content') 862 all_params.append('_request_timeout') 863 864 params = locals() 865 for key, val in iteritems(params['kwargs']): 866 if key not in all_params: 867 raise TypeError( 868 "Got an unexpected keyword argument '%s'" 869 " to method delete" % key 870 ) 871 params[key] = val 872 del params['kwargs'] 873 # verify the required parameter 'account_id' is set 874 if ('account_id' not in params) or (params['account_id'] is None): 875 raise ValueError("Missing the required parameter `account_id` when calling `delete`") 876 877 878 collection_formats = {} 879 880 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 881 path_params = {} 882 if 'account_id' in params: 883 path_params['accountId'] = params['account_id'] 884 885 query_params = {} 886 887 header_params = {} 888 889 form_params = [] 890 local_var_files = {} 891 892 body_params = None 893 # HTTP header `Accept` 894 header_params['Accept'] = self.api_client.\ 895 select_header_accept(['application/json']) 896 897 # Authentication setting 898 auth_settings = [] 899 900 return self.api_client.call_api(resource_path, 'DELETE', 901 path_params, 902 query_params, 903 header_params, 904 body=body_params, 905 post_params=form_params, 906 files=local_var_files, 907 response_type=None, 908 auth_settings=auth_settings, 909 callback=params.get('callback'), 910 _return_http_data_only=params.get('_return_http_data_only'), 911 _preload_content=params.get('_preload_content', True), 912 _request_timeout=params.get('_request_timeout'), 913 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)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_account_signature(self, account_id, signature_id, **kwargs)
915 def delete_account_signature(self, account_id, signature_id, **kwargs): 916 """ 917 Close the specified signature by Id. 918 919 This method makes a synchronous HTTP request by default. To make an 920 asynchronous HTTP request, please define a `callback` function 921 to be invoked when receiving the response. 922 >>> def callback_function(response): 923 >>> pprint(response) 924 >>> 925 >>> thread = api.delete_account_signature(account_id, signature_id, callback=callback_function) 926 927 :param callback function: The callback function 928 for asynchronous request. (optional) 929 :param str account_id: The external account number (int) or account ID Guid. (required) 930 :param str signature_id: The ID of the signature being accessed. (required) 931 :return: None 932 If the method is called asynchronously, 933 returns the request thread. 934 """ 935 kwargs['_return_http_data_only'] = True 936 if kwargs.get('callback'): 937 return self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 938 else: 939 (data) = self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 940 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)
942 def delete_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 943 """ 944 Close the specified signature by Id. 945 946 This method makes a synchronous HTTP request by default. To make an 947 asynchronous HTTP request, please define a `callback` function 948 to be invoked when receiving the response. 949 >>> def callback_function(response): 950 >>> pprint(response) 951 >>> 952 >>> thread = api.delete_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 953 954 :param callback function: The callback function 955 for asynchronous request. (optional) 956 :param str account_id: The external account number (int) or account ID Guid. (required) 957 :param str signature_id: The ID of the signature being accessed. (required) 958 :return: None 959 If the method is called asynchronously, 960 returns the request thread. 961 """ 962 963 all_params = ['account_id', 'signature_id'] 964 all_params.append('callback') 965 all_params.append('_return_http_data_only') 966 all_params.append('_preload_content') 967 all_params.append('_request_timeout') 968 969 params = locals() 970 for key, val in iteritems(params['kwargs']): 971 if key not in all_params: 972 raise TypeError( 973 "Got an unexpected keyword argument '%s'" 974 " to method delete_account_signature" % key 975 ) 976 params[key] = val 977 del params['kwargs'] 978 # verify the required parameter 'account_id' is set 979 if ('account_id' not in params) or (params['account_id'] is None): 980 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature`") 981 # verify the required parameter 'signature_id' is set 982 if ('signature_id' not in params) or (params['signature_id'] is None): 983 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature`") 984 985 986 collection_formats = {} 987 988 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 989 path_params = {} 990 if 'account_id' in params: 991 path_params['accountId'] = params['account_id'] 992 if 'signature_id' in params: 993 path_params['signatureId'] = params['signature_id'] 994 995 query_params = {} 996 997 header_params = {} 998 999 form_params = [] 1000 local_var_files = {} 1001 1002 body_params = None 1003 # HTTP header `Accept` 1004 header_params['Accept'] = self.api_client.\ 1005 select_header_accept(['application/json']) 1006 1007 # Authentication setting 1008 auth_settings = [] 1009 1010 return self.api_client.call_api(resource_path, 'DELETE', 1011 path_params, 1012 query_params, 1013 header_params, 1014 body=body_params, 1015 post_params=form_params, 1016 files=local_var_files, 1017 response_type=None, 1018 auth_settings=auth_settings, 1019 callback=params.get('callback'), 1020 _return_http_data_only=params.get('_return_http_data_only'), 1021 _preload_content=params.get('_preload_content', True), 1022 _request_timeout=params.get('_request_timeout'), 1023 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)
1025 def delete_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 1026 """ 1027 Deletes a signature, initials, or stamps image. 1028 1029 This method makes a synchronous HTTP request by default. To make an 1030 asynchronous HTTP request, please define a `callback` function 1031 to be invoked when receiving the response. 1032 >>> def callback_function(response): 1033 >>> pprint(response) 1034 >>> 1035 >>> thread = api.delete_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 1036 1037 :param callback function: The callback function 1038 for asynchronous request. (optional) 1039 :param str account_id: The external account number (int) or account ID Guid. (required) 1040 :param str image_type: One of **signature_image** or **initials_image**. (required) 1041 :param str signature_id: The ID of the signature being accessed. (required) 1042 :return: AccountSignature 1043 If the method is called asynchronously, 1044 returns the request thread. 1045 """ 1046 kwargs['_return_http_data_only'] = True 1047 if kwargs.get('callback'): 1048 return self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 1049 else: 1050 (data) = self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 1051 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)
1053 def delete_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 1054 """ 1055 Deletes a signature, initials, or stamps image. 1056 1057 This method makes a synchronous HTTP request by default. To make an 1058 asynchronous HTTP request, please define a `callback` function 1059 to be invoked when receiving the response. 1060 >>> def callback_function(response): 1061 >>> pprint(response) 1062 >>> 1063 >>> thread = api.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 1064 1065 :param callback function: The callback function 1066 for asynchronous request. (optional) 1067 :param str account_id: The external account number (int) or account ID Guid. (required) 1068 :param str image_type: One of **signature_image** or **initials_image**. (required) 1069 :param str signature_id: The ID of the signature being accessed. (required) 1070 :return: AccountSignature 1071 If the method is called asynchronously, 1072 returns the request thread. 1073 """ 1074 1075 all_params = ['account_id', 'image_type', 'signature_id'] 1076 all_params.append('callback') 1077 all_params.append('_return_http_data_only') 1078 all_params.append('_preload_content') 1079 all_params.append('_request_timeout') 1080 1081 params = locals() 1082 for key, val in iteritems(params['kwargs']): 1083 if key not in all_params: 1084 raise TypeError( 1085 "Got an unexpected keyword argument '%s'" 1086 " to method delete_account_signature_image" % key 1087 ) 1088 params[key] = val 1089 del params['kwargs'] 1090 # verify the required parameter 'account_id' is set 1091 if ('account_id' not in params) or (params['account_id'] is None): 1092 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature_image`") 1093 # verify the required parameter 'image_type' is set 1094 if ('image_type' not in params) or (params['image_type'] is None): 1095 raise ValueError("Missing the required parameter `image_type` when calling `delete_account_signature_image`") 1096 # verify the required parameter 'signature_id' is set 1097 if ('signature_id' not in params) or (params['signature_id'] is None): 1098 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature_image`") 1099 1100 1101 collection_formats = {} 1102 1103 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 1104 path_params = {} 1105 if 'account_id' in params: 1106 path_params['accountId'] = params['account_id'] 1107 if 'image_type' in params: 1108 path_params['imageType'] = params['image_type'] 1109 if 'signature_id' in params: 1110 path_params['signatureId'] = params['signature_id'] 1111 1112 query_params = {} 1113 1114 header_params = {} 1115 1116 form_params = [] 1117 local_var_files = {} 1118 1119 body_params = None 1120 # HTTP header `Accept` 1121 header_params['Accept'] = self.api_client.\ 1122 select_header_accept(['application/json']) 1123 1124 # Authentication setting 1125 auth_settings = [] 1126 1127 return self.api_client.call_api(resource_path, 'DELETE', 1128 path_params, 1129 query_params, 1130 header_params, 1131 body=body_params, 1132 post_params=form_params, 1133 files=local_var_files, 1134 response_type='AccountSignature', 1135 auth_settings=auth_settings, 1136 callback=params.get('callback'), 1137 _return_http_data_only=params.get('_return_http_data_only'), 1138 _preload_content=params.get('_preload_content', True), 1139 _request_timeout=params.get('_request_timeout'), 1140 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)
1142 def delete_brand(self, account_id, brand_id, **kwargs): 1143 """ 1144 Removes a brand. 1145 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**). 1146 This method makes a synchronous HTTP request by default. To make an 1147 asynchronous HTTP request, please define a `callback` function 1148 to be invoked when receiving the response. 1149 >>> def callback_function(response): 1150 >>> pprint(response) 1151 >>> 1152 >>> thread = api.delete_brand(account_id, brand_id, callback=callback_function) 1153 1154 :param callback function: The callback function 1155 for asynchronous request. (optional) 1156 :param str account_id: The external account number (int) or account ID Guid. (required) 1157 :param str brand_id: The unique identifier of a brand. (required) 1158 :return: None 1159 If the method is called asynchronously, 1160 returns the request thread. 1161 """ 1162 kwargs['_return_http_data_only'] = True 1163 if kwargs.get('callback'): 1164 return self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 1165 else: 1166 (data) = self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 1167 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)
1169 def delete_brand_with_http_info(self, account_id, brand_id, **kwargs): 1170 """ 1171 Removes a brand. 1172 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**). 1173 This method makes a synchronous HTTP request by default. To make an 1174 asynchronous HTTP request, please define a `callback` function 1175 to be invoked when receiving the response. 1176 >>> def callback_function(response): 1177 >>> pprint(response) 1178 >>> 1179 >>> thread = api.delete_brand_with_http_info(account_id, brand_id, callback=callback_function) 1180 1181 :param callback function: The callback function 1182 for asynchronous request. (optional) 1183 :param str account_id: The external account number (int) or account ID Guid. (required) 1184 :param str brand_id: The unique identifier of a brand. (required) 1185 :return: None 1186 If the method is called asynchronously, 1187 returns the request thread. 1188 """ 1189 1190 all_params = ['account_id', 'brand_id'] 1191 all_params.append('callback') 1192 all_params.append('_return_http_data_only') 1193 all_params.append('_preload_content') 1194 all_params.append('_request_timeout') 1195 1196 params = locals() 1197 for key, val in iteritems(params['kwargs']): 1198 if key not in all_params: 1199 raise TypeError( 1200 "Got an unexpected keyword argument '%s'" 1201 " to method delete_brand" % key 1202 ) 1203 params[key] = val 1204 del params['kwargs'] 1205 # verify the required parameter 'account_id' is set 1206 if ('account_id' not in params) or (params['account_id'] is None): 1207 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand`") 1208 # verify the required parameter 'brand_id' is set 1209 if ('brand_id' not in params) or (params['brand_id'] is None): 1210 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand`") 1211 1212 1213 collection_formats = {} 1214 1215 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 1216 path_params = {} 1217 if 'account_id' in params: 1218 path_params['accountId'] = params['account_id'] 1219 if 'brand_id' in params: 1220 path_params['brandId'] = params['brand_id'] 1221 1222 query_params = {} 1223 1224 header_params = {} 1225 1226 form_params = [] 1227 local_var_files = {} 1228 1229 body_params = None 1230 # HTTP header `Accept` 1231 header_params['Accept'] = self.api_client.\ 1232 select_header_accept(['application/json']) 1233 1234 # Authentication setting 1235 auth_settings = [] 1236 1237 return self.api_client.call_api(resource_path, 'DELETE', 1238 path_params, 1239 query_params, 1240 header_params, 1241 body=body_params, 1242 post_params=form_params, 1243 files=local_var_files, 1244 response_type=None, 1245 auth_settings=auth_settings, 1246 callback=params.get('callback'), 1247 _return_http_data_only=params.get('_return_http_data_only'), 1248 _preload_content=params.get('_preload_content', True), 1249 _request_timeout=params.get('_request_timeout'), 1250 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)
1252 def delete_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 1253 """ 1254 Delete one branding logo. 1255 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**). 1256 This method makes a synchronous HTTP request by default. To make an 1257 asynchronous HTTP request, please define a `callback` function 1258 to be invoked when receiving the response. 1259 >>> def callback_function(response): 1260 >>> pprint(response) 1261 >>> 1262 >>> thread = api.delete_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 1263 1264 :param callback function: The callback function 1265 for asynchronous request. (optional) 1266 :param str account_id: The external account number (int) or account ID Guid. (required) 1267 :param str brand_id: The unique identifier of a brand. (required) 1268 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1269 :return: None 1270 If the method is called asynchronously, 1271 returns the request thread. 1272 """ 1273 kwargs['_return_http_data_only'] = True 1274 if kwargs.get('callback'): 1275 return self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1276 else: 1277 (data) = self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1278 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)
1280 def delete_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 1281 """ 1282 Delete one branding logo. 1283 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**). 1284 This method makes a synchronous HTTP request by default. To make an 1285 asynchronous HTTP request, please define a `callback` function 1286 to be invoked when receiving the response. 1287 >>> def callback_function(response): 1288 >>> pprint(response) 1289 >>> 1290 >>> thread = api.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 1291 1292 :param callback function: The callback function 1293 for asynchronous request. (optional) 1294 :param str account_id: The external account number (int) or account ID Guid. (required) 1295 :param str brand_id: The unique identifier of a brand. (required) 1296 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1297 :return: None 1298 If the method is called asynchronously, 1299 returns the request thread. 1300 """ 1301 1302 all_params = ['account_id', 'brand_id', 'logo_type'] 1303 all_params.append('callback') 1304 all_params.append('_return_http_data_only') 1305 all_params.append('_preload_content') 1306 all_params.append('_request_timeout') 1307 1308 params = locals() 1309 for key, val in iteritems(params['kwargs']): 1310 if key not in all_params: 1311 raise TypeError( 1312 "Got an unexpected keyword argument '%s'" 1313 " to method delete_brand_logo_by_type" % key 1314 ) 1315 params[key] = val 1316 del params['kwargs'] 1317 # verify the required parameter 'account_id' is set 1318 if ('account_id' not in params) or (params['account_id'] is None): 1319 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand_logo_by_type`") 1320 # verify the required parameter 'brand_id' is set 1321 if ('brand_id' not in params) or (params['brand_id'] is None): 1322 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand_logo_by_type`") 1323 # verify the required parameter 'logo_type' is set 1324 if ('logo_type' not in params) or (params['logo_type'] is None): 1325 raise ValueError("Missing the required parameter `logo_type` when calling `delete_brand_logo_by_type`") 1326 1327 1328 collection_formats = {} 1329 1330 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 1331 path_params = {} 1332 if 'account_id' in params: 1333 path_params['accountId'] = params['account_id'] 1334 if 'brand_id' in params: 1335 path_params['brandId'] = params['brand_id'] 1336 if 'logo_type' in params: 1337 path_params['logoType'] = params['logo_type'] 1338 1339 query_params = {} 1340 1341 header_params = {} 1342 1343 form_params = [] 1344 local_var_files = {} 1345 1346 body_params = None 1347 # HTTP header `Accept` 1348 header_params['Accept'] = self.api_client.\ 1349 select_header_accept(['application/json']) 1350 1351 # Authentication setting 1352 auth_settings = [] 1353 1354 return self.api_client.call_api(resource_path, 'DELETE', 1355 path_params, 1356 query_params, 1357 header_params, 1358 body=body_params, 1359 post_params=form_params, 1360 files=local_var_files, 1361 response_type=None, 1362 auth_settings=auth_settings, 1363 callback=params.get('callback'), 1364 _return_http_data_only=params.get('_return_http_data_only'), 1365 _preload_content=params.get('_preload_content', True), 1366 _request_timeout=params.get('_request_timeout'), 1367 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)
1369 def delete_brands(self, account_id, **kwargs): 1370 """ 1371 Deletes one or more brand profiles. 1372 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. 1373 This method makes a synchronous HTTP request by default. To make an 1374 asynchronous HTTP request, please define a `callback` function 1375 to be invoked when receiving the response. 1376 >>> def callback_function(response): 1377 >>> pprint(response) 1378 >>> 1379 >>> thread = api.delete_brands(account_id, callback=callback_function) 1380 1381 :param callback function: The callback function 1382 for asynchronous request. (optional) 1383 :param str account_id: The external account number (int) or account ID Guid. (required) 1384 :param BrandsRequest brands_request: 1385 :return: BrandsResponse 1386 If the method is called asynchronously, 1387 returns the request thread. 1388 """ 1389 kwargs['_return_http_data_only'] = True 1390 if kwargs.get('callback'): 1391 return self.delete_brands_with_http_info(account_id, **kwargs) 1392 else: 1393 (data) = self.delete_brands_with_http_info(account_id, **kwargs) 1394 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)
1396 def delete_brands_with_http_info(self, account_id, **kwargs): 1397 """ 1398 Deletes one or more brand profiles. 1399 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. 1400 This method makes a synchronous HTTP request by default. To make an 1401 asynchronous HTTP request, please define a `callback` function 1402 to be invoked when receiving the response. 1403 >>> def callback_function(response): 1404 >>> pprint(response) 1405 >>> 1406 >>> thread = api.delete_brands_with_http_info(account_id, callback=callback_function) 1407 1408 :param callback function: The callback function 1409 for asynchronous request. (optional) 1410 :param str account_id: The external account number (int) or account ID Guid. (required) 1411 :param BrandsRequest brands_request: 1412 :return: BrandsResponse 1413 If the method is called asynchronously, 1414 returns the request thread. 1415 """ 1416 1417 all_params = ['account_id', 'brands_request'] 1418 all_params.append('callback') 1419 all_params.append('_return_http_data_only') 1420 all_params.append('_preload_content') 1421 all_params.append('_request_timeout') 1422 1423 params = locals() 1424 for key, val in iteritems(params['kwargs']): 1425 if key not in all_params: 1426 raise TypeError( 1427 "Got an unexpected keyword argument '%s'" 1428 " to method delete_brands" % key 1429 ) 1430 params[key] = val 1431 del params['kwargs'] 1432 # verify the required parameter 'account_id' is set 1433 if ('account_id' not in params) or (params['account_id'] is None): 1434 raise ValueError("Missing the required parameter `account_id` when calling `delete_brands`") 1435 1436 1437 collection_formats = {} 1438 1439 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 1440 path_params = {} 1441 if 'account_id' in params: 1442 path_params['accountId'] = params['account_id'] 1443 1444 query_params = {} 1445 1446 header_params = {} 1447 1448 form_params = [] 1449 local_var_files = {} 1450 1451 body_params = None 1452 if 'brands_request' in params: 1453 body_params = params['brands_request'] 1454 # HTTP header `Accept` 1455 header_params['Accept'] = self.api_client.\ 1456 select_header_accept(['application/json']) 1457 1458 # Authentication setting 1459 auth_settings = [] 1460 1461 return self.api_client.call_api(resource_path, 'DELETE', 1462 path_params, 1463 query_params, 1464 header_params, 1465 body=body_params, 1466 post_params=form_params, 1467 files=local_var_files, 1468 response_type='BrandsResponse', 1469 auth_settings=auth_settings, 1470 callback=params.get('callback'), 1471 _return_http_data_only=params.get('_return_http_data_only'), 1472 _preload_content=params.get('_preload_content', True), 1473 _request_timeout=params.get('_request_timeout'), 1474 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)
1476 def delete_captive_recipient(self, account_id, recipient_part, **kwargs): 1477 """ 1478 Deletes the signature for one or more captive recipient records. 1479 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. 1480 This method makes a synchronous HTTP request by default. To make an 1481 asynchronous HTTP request, please define a `callback` function 1482 to be invoked when receiving the response. 1483 >>> def callback_function(response): 1484 >>> pprint(response) 1485 >>> 1486 >>> thread = api.delete_captive_recipient(account_id, recipient_part, callback=callback_function) 1487 1488 :param callback function: The callback function 1489 for asynchronous request. (optional) 1490 :param str account_id: The external account number (int) or account ID Guid. (required) 1491 :param str recipient_part: (required) 1492 :param CaptiveRecipientInformation captive_recipient_information: 1493 :return: CaptiveRecipientInformation 1494 If the method is called asynchronously, 1495 returns the request thread. 1496 """ 1497 kwargs['_return_http_data_only'] = True 1498 if kwargs.get('callback'): 1499 return self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1500 else: 1501 (data) = self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1502 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)
1504 def delete_captive_recipient_with_http_info(self, account_id, recipient_part, **kwargs): 1505 """ 1506 Deletes the signature for one or more captive recipient records. 1507 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. 1508 This method makes a synchronous HTTP request by default. To make an 1509 asynchronous HTTP request, please define a `callback` function 1510 to be invoked when receiving the response. 1511 >>> def callback_function(response): 1512 >>> pprint(response) 1513 >>> 1514 >>> thread = api.delete_captive_recipient_with_http_info(account_id, recipient_part, callback=callback_function) 1515 1516 :param callback function: The callback function 1517 for asynchronous request. (optional) 1518 :param str account_id: The external account number (int) or account ID Guid. (required) 1519 :param str recipient_part: (required) 1520 :param CaptiveRecipientInformation captive_recipient_information: 1521 :return: CaptiveRecipientInformation 1522 If the method is called asynchronously, 1523 returns the request thread. 1524 """ 1525 1526 all_params = ['account_id', 'recipient_part', 'captive_recipient_information'] 1527 all_params.append('callback') 1528 all_params.append('_return_http_data_only') 1529 all_params.append('_preload_content') 1530 all_params.append('_request_timeout') 1531 1532 params = locals() 1533 for key, val in iteritems(params['kwargs']): 1534 if key not in all_params: 1535 raise TypeError( 1536 "Got an unexpected keyword argument '%s'" 1537 " to method delete_captive_recipient" % key 1538 ) 1539 params[key] = val 1540 del params['kwargs'] 1541 # verify the required parameter 'account_id' is set 1542 if ('account_id' not in params) or (params['account_id'] is None): 1543 raise ValueError("Missing the required parameter `account_id` when calling `delete_captive_recipient`") 1544 # verify the required parameter 'recipient_part' is set 1545 if ('recipient_part' not in params) or (params['recipient_part'] is None): 1546 raise ValueError("Missing the required parameter `recipient_part` when calling `delete_captive_recipient`") 1547 1548 1549 collection_formats = {} 1550 1551 resource_path = '/v2.1/accounts/{accountId}/captive_recipients/{recipientPart}'.replace('{format}', 'json') 1552 path_params = {} 1553 if 'account_id' in params: 1554 path_params['accountId'] = params['account_id'] 1555 if 'recipient_part' in params: 1556 path_params['recipientPart'] = params['recipient_part'] 1557 1558 query_params = {} 1559 1560 header_params = {} 1561 1562 form_params = [] 1563 local_var_files = {} 1564 1565 body_params = None 1566 if 'captive_recipient_information' in params: 1567 body_params = params['captive_recipient_information'] 1568 # HTTP header `Accept` 1569 header_params['Accept'] = self.api_client.\ 1570 select_header_accept(['application/json']) 1571 1572 # Authentication setting 1573 auth_settings = [] 1574 1575 return self.api_client.call_api(resource_path, 'DELETE', 1576 path_params, 1577 query_params, 1578 header_params, 1579 body=body_params, 1580 post_params=form_params, 1581 files=local_var_files, 1582 response_type='CaptiveRecipientInformation', 1583 auth_settings=auth_settings, 1584 callback=params.get('callback'), 1585 _return_http_data_only=params.get('_return_http_data_only'), 1586 _preload_content=params.get('_preload_content', True), 1587 _request_timeout=params.get('_request_timeout'), 1588 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)
1590 def delete_custom_field(self, account_id, custom_field_id, **kwargs): 1591 """ 1592 Delete an existing account custom field. 1593 This method deletes an existing account custom field. 1594 This method makes a synchronous HTTP request by default. To make an 1595 asynchronous HTTP request, please define a `callback` function 1596 to be invoked when receiving the response. 1597 >>> def callback_function(response): 1598 >>> pprint(response) 1599 >>> 1600 >>> thread = api.delete_custom_field(account_id, custom_field_id, callback=callback_function) 1601 1602 :param callback function: The callback function 1603 for asynchronous request. (optional) 1604 :param str account_id: The external account number (int) or account ID Guid. (required) 1605 :param str custom_field_id: (required) 1606 :param str apply_to_templates: 1607 :return: None 1608 If the method is called asynchronously, 1609 returns the request thread. 1610 """ 1611 kwargs['_return_http_data_only'] = True 1612 if kwargs.get('callback'): 1613 return self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1614 else: 1615 (data) = self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1616 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)
1618 def delete_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 1619 """ 1620 Delete an existing account custom field. 1621 This method deletes an existing account custom field. 1622 This method makes a synchronous HTTP request by default. To make an 1623 asynchronous HTTP request, please define a `callback` function 1624 to be invoked when receiving the response. 1625 >>> def callback_function(response): 1626 >>> pprint(response) 1627 >>> 1628 >>> thread = api.delete_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 1629 1630 :param callback function: The callback function 1631 for asynchronous request. (optional) 1632 :param str account_id: The external account number (int) or account ID Guid. (required) 1633 :param str custom_field_id: (required) 1634 :param str apply_to_templates: 1635 :return: None 1636 If the method is called asynchronously, 1637 returns the request thread. 1638 """ 1639 1640 all_params = ['account_id', 'custom_field_id', 'apply_to_templates'] 1641 all_params.append('callback') 1642 all_params.append('_return_http_data_only') 1643 all_params.append('_preload_content') 1644 all_params.append('_request_timeout') 1645 1646 params = locals() 1647 for key, val in iteritems(params['kwargs']): 1648 if key not in all_params: 1649 raise TypeError( 1650 "Got an unexpected keyword argument '%s'" 1651 " to method delete_custom_field" % key 1652 ) 1653 params[key] = val 1654 del params['kwargs'] 1655 # verify the required parameter 'account_id' is set 1656 if ('account_id' not in params) or (params['account_id'] is None): 1657 raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_field`") 1658 # verify the required parameter 'custom_field_id' is set 1659 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 1660 raise ValueError("Missing the required parameter `custom_field_id` when calling `delete_custom_field`") 1661 1662 1663 collection_formats = {} 1664 1665 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 1666 path_params = {} 1667 if 'account_id' in params: 1668 path_params['accountId'] = params['account_id'] 1669 if 'custom_field_id' in params: 1670 path_params['customFieldId'] = params['custom_field_id'] 1671 1672 query_params = {} 1673 if 'apply_to_templates' in params: 1674 query_params['apply_to_templates'] = params['apply_to_templates'] 1675 1676 header_params = {} 1677 1678 form_params = [] 1679 local_var_files = {} 1680 1681 body_params = None 1682 # HTTP header `Accept` 1683 header_params['Accept'] = self.api_client.\ 1684 select_header_accept(['application/json']) 1685 1686 # Authentication setting 1687 auth_settings = [] 1688 1689 return self.api_client.call_api(resource_path, 'DELETE', 1690 path_params, 1691 query_params, 1692 header_params, 1693 body=body_params, 1694 post_params=form_params, 1695 files=local_var_files, 1696 response_type=None, 1697 auth_settings=auth_settings, 1698 callback=params.get('callback'), 1699 _return_http_data_only=params.get('_return_http_data_only'), 1700 _preload_content=params.get('_preload_content', True), 1701 _request_timeout=params.get('_request_timeout'), 1702 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)
1704 def delete_e_note_configuration(self, account_id, **kwargs): 1705 """ 1706 Deletes configuration information for the eNote eOriginal integration. 1707 1708 This method makes a synchronous HTTP request by default. To make an 1709 asynchronous HTTP request, please define a `callback` function 1710 to be invoked when receiving the response. 1711 >>> def callback_function(response): 1712 >>> pprint(response) 1713 >>> 1714 >>> thread = api.delete_e_note_configuration(account_id, callback=callback_function) 1715 1716 :param callback function: The callback function 1717 for asynchronous request. (optional) 1718 :param str account_id: The external account number (int) or account ID Guid. (required) 1719 :return: None 1720 If the method is called asynchronously, 1721 returns the request thread. 1722 """ 1723 kwargs['_return_http_data_only'] = True 1724 if kwargs.get('callback'): 1725 return self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1726 else: 1727 (data) = self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1728 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)
1730 def delete_e_note_configuration_with_http_info(self, account_id, **kwargs): 1731 """ 1732 Deletes configuration information for the eNote eOriginal integration. 1733 1734 This method makes a synchronous HTTP request by default. To make an 1735 asynchronous HTTP request, please define a `callback` function 1736 to be invoked when receiving the response. 1737 >>> def callback_function(response): 1738 >>> pprint(response) 1739 >>> 1740 >>> thread = api.delete_e_note_configuration_with_http_info(account_id, callback=callback_function) 1741 1742 :param callback function: The callback function 1743 for asynchronous request. (optional) 1744 :param str account_id: The external account number (int) or account ID Guid. (required) 1745 :return: None 1746 If the method is called asynchronously, 1747 returns the request thread. 1748 """ 1749 1750 all_params = ['account_id'] 1751 all_params.append('callback') 1752 all_params.append('_return_http_data_only') 1753 all_params.append('_preload_content') 1754 all_params.append('_request_timeout') 1755 1756 params = locals() 1757 for key, val in iteritems(params['kwargs']): 1758 if key not in all_params: 1759 raise TypeError( 1760 "Got an unexpected keyword argument '%s'" 1761 " to method delete_e_note_configuration" % key 1762 ) 1763 params[key] = val 1764 del params['kwargs'] 1765 # verify the required parameter 'account_id' is set 1766 if ('account_id' not in params) or (params['account_id'] is None): 1767 raise ValueError("Missing the required parameter `account_id` when calling `delete_e_note_configuration`") 1768 1769 1770 collection_formats = {} 1771 1772 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 1773 path_params = {} 1774 if 'account_id' in params: 1775 path_params['accountId'] = params['account_id'] 1776 1777 query_params = {} 1778 1779 header_params = {} 1780 1781 form_params = [] 1782 local_var_files = {} 1783 1784 body_params = None 1785 # HTTP header `Accept` 1786 header_params['Accept'] = self.api_client.\ 1787 select_header_accept(['application/json']) 1788 1789 # Authentication setting 1790 auth_settings = [] 1791 1792 return self.api_client.call_api(resource_path, 'DELETE', 1793 path_params, 1794 query_params, 1795 header_params, 1796 body=body_params, 1797 post_params=form_params, 1798 files=local_var_files, 1799 response_type=None, 1800 auth_settings=auth_settings, 1801 callback=params.get('callback'), 1802 _return_http_data_only=params.get('_return_http_data_only'), 1803 _preload_content=params.get('_preload_content', True), 1804 _request_timeout=params.get('_request_timeout'), 1805 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)
1807 def delete_permission_profile(self, account_id, permission_profile_id, **kwargs): 1808 """ 1809 Deletes a permissions profile within the specified account. 1810 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/) 1811 This method makes a synchronous HTTP request by default. To make an 1812 asynchronous HTTP request, please define a `callback` function 1813 to be invoked when receiving the response. 1814 >>> def callback_function(response): 1815 >>> pprint(response) 1816 >>> 1817 >>> thread = api.delete_permission_profile(account_id, permission_profile_id, callback=callback_function) 1818 1819 :param callback function: The callback function 1820 for asynchronous request. (optional) 1821 :param str account_id: The external account number (int) or account ID Guid. (required) 1822 :param str permission_profile_id: (required) 1823 :param str move_users_to: 1824 :return: None 1825 If the method is called asynchronously, 1826 returns the request thread. 1827 """ 1828 kwargs['_return_http_data_only'] = True 1829 if kwargs.get('callback'): 1830 return self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1831 else: 1832 (data) = self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1833 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)
1835 def delete_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 1836 """ 1837 Deletes a permissions profile within the specified account. 1838 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/) 1839 This method makes a synchronous HTTP request by default. To make an 1840 asynchronous HTTP request, please define a `callback` function 1841 to be invoked when receiving the response. 1842 >>> def callback_function(response): 1843 >>> pprint(response) 1844 >>> 1845 >>> thread = api.delete_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 1846 1847 :param callback function: The callback function 1848 for asynchronous request. (optional) 1849 :param str account_id: The external account number (int) or account ID Guid. (required) 1850 :param str permission_profile_id: (required) 1851 :param str move_users_to: 1852 :return: None 1853 If the method is called asynchronously, 1854 returns the request thread. 1855 """ 1856 1857 all_params = ['account_id', 'permission_profile_id', 'move_users_to'] 1858 all_params.append('callback') 1859 all_params.append('_return_http_data_only') 1860 all_params.append('_preload_content') 1861 all_params.append('_request_timeout') 1862 1863 params = locals() 1864 for key, val in iteritems(params['kwargs']): 1865 if key not in all_params: 1866 raise TypeError( 1867 "Got an unexpected keyword argument '%s'" 1868 " to method delete_permission_profile" % key 1869 ) 1870 params[key] = val 1871 del params['kwargs'] 1872 # verify the required parameter 'account_id' is set 1873 if ('account_id' not in params) or (params['account_id'] is None): 1874 raise ValueError("Missing the required parameter `account_id` when calling `delete_permission_profile`") 1875 # verify the required parameter 'permission_profile_id' is set 1876 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 1877 raise ValueError("Missing the required parameter `permission_profile_id` when calling `delete_permission_profile`") 1878 1879 1880 collection_formats = {} 1881 1882 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 1883 path_params = {} 1884 if 'account_id' in params: 1885 path_params['accountId'] = params['account_id'] 1886 if 'permission_profile_id' in params: 1887 path_params['permissionProfileId'] = params['permission_profile_id'] 1888 1889 query_params = {} 1890 if 'move_users_to' in params: 1891 query_params['move_users_to'] = params['move_users_to'] 1892 1893 header_params = {} 1894 1895 form_params = [] 1896 local_var_files = {} 1897 1898 body_params = None 1899 # HTTP header `Accept` 1900 header_params['Accept'] = self.api_client.\ 1901 select_header_accept(['application/json']) 1902 1903 # Authentication setting 1904 auth_settings = [] 1905 1906 return self.api_client.call_api(resource_path, 'DELETE', 1907 path_params, 1908 query_params, 1909 header_params, 1910 body=body_params, 1911 post_params=form_params, 1912 files=local_var_files, 1913 response_type=None, 1914 auth_settings=auth_settings, 1915 callback=params.get('callback'), 1916 _return_http_data_only=params.get('_return_http_data_only'), 1917 _preload_content=params.get('_preload_content', True), 1918 _request_timeout=params.get('_request_timeout'), 1919 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)
2148 def get_account_identity_verification(self, account_id, **kwargs): 2149 """ 2150 Get the list of identity verification options for an account 2151 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/) 2152 This method makes a synchronous HTTP request by default. To make an 2153 asynchronous HTTP request, please define a `callback` function 2154 to be invoked when receiving the response. 2155 >>> def callback_function(response): 2156 >>> pprint(response) 2157 >>> 2158 >>> thread = api.get_account_identity_verification(account_id, callback=callback_function) 2159 2160 :param callback function: The callback function 2161 for asynchronous request. (optional) 2162 :param str account_id: The external account number (int) or account ID Guid. (required) 2163 :return: AccountIdentityVerificationResponse 2164 If the method is called asynchronously, 2165 returns the request thread. 2166 """ 2167 kwargs['_return_http_data_only'] = True 2168 if kwargs.get('callback'): 2169 return self.get_account_identity_verification_with_http_info(account_id, **kwargs) 2170 else: 2171 (data) = self.get_account_identity_verification_with_http_info(account_id, **kwargs) 2172 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)
Returns
AccountIdentityVerificationResponse If the method is called asynchronously, returns the request thread.
def
get_account_identity_verification_with_http_info(self, account_id, **kwargs)
2174 def get_account_identity_verification_with_http_info(self, account_id, **kwargs): 2175 """ 2176 Get the list of identity verification options for an account 2177 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/) 2178 This method makes a synchronous HTTP request by default. To make an 2179 asynchronous HTTP request, please define a `callback` function 2180 to be invoked when receiving the response. 2181 >>> def callback_function(response): 2182 >>> pprint(response) 2183 >>> 2184 >>> thread = api.get_account_identity_verification_with_http_info(account_id, callback=callback_function) 2185 2186 :param callback function: The callback function 2187 for asynchronous request. (optional) 2188 :param str account_id: The external account number (int) or account ID Guid. (required) 2189 :return: AccountIdentityVerificationResponse 2190 If the method is called asynchronously, 2191 returns the request thread. 2192 """ 2193 2194 all_params = ['account_id'] 2195 all_params.append('callback') 2196 all_params.append('_return_http_data_only') 2197 all_params.append('_preload_content') 2198 all_params.append('_request_timeout') 2199 2200 params = locals() 2201 for key, val in iteritems(params['kwargs']): 2202 if key not in all_params: 2203 raise TypeError( 2204 "Got an unexpected keyword argument '%s'" 2205 " to method get_account_identity_verification" % key 2206 ) 2207 params[key] = val 2208 del params['kwargs'] 2209 # verify the required parameter 'account_id' is set 2210 if ('account_id' not in params) or (params['account_id'] is None): 2211 raise ValueError("Missing the required parameter `account_id` when calling `get_account_identity_verification`") 2212 2213 2214 collection_formats = {} 2215 2216 resource_path = '/v2.1/accounts/{accountId}/identity_verification'.replace('{format}', 'json') 2217 path_params = {} 2218 if 'account_id' in params: 2219 path_params['accountId'] = params['account_id'] 2220 2221 query_params = {} 2222 2223 header_params = {} 2224 2225 form_params = [] 2226 local_var_files = {} 2227 2228 body_params = None 2229 # HTTP header `Accept` 2230 header_params['Accept'] = self.api_client.\ 2231 select_header_accept(['application/json']) 2232 2233 # Authentication setting 2234 auth_settings = [] 2235 2236 return self.api_client.call_api(resource_path, 'GET', 2237 path_params, 2238 query_params, 2239 header_params, 2240 body=body_params, 2241 post_params=form_params, 2242 files=local_var_files, 2243 response_type='AccountIdentityVerificationResponse', 2244 auth_settings=auth_settings, 2245 callback=params.get('callback'), 2246 _return_http_data_only=params.get('_return_http_data_only'), 2247 _preload_content=params.get('_preload_content', True), 2248 _request_timeout=params.get('_request_timeout'), 2249 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)
Returns
AccountIdentityVerificationResponse If the method is called asynchronously, returns the request thread.
def
get_account_information(self, account_id, **kwargs)
2251 def get_account_information(self, account_id, **kwargs): 2252 """ 2253 Retrieves the account information for the specified account. 2254 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. 2255 This method makes a synchronous HTTP request by default. To make an 2256 asynchronous HTTP request, please define a `callback` function 2257 to be invoked when receiving the response. 2258 >>> def callback_function(response): 2259 >>> pprint(response) 2260 >>> 2261 >>> thread = api.get_account_information(account_id, callback=callback_function) 2262 2263 :param callback function: The callback function 2264 for asynchronous request. (optional) 2265 :param str account_id: The external account number (int) or account ID Guid. (required) 2266 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 2267 :return: AccountInformation 2268 If the method is called asynchronously, 2269 returns the request thread. 2270 """ 2271 kwargs['_return_http_data_only'] = True 2272 if kwargs.get('callback'): 2273 return self.get_account_information_with_http_info(account_id, **kwargs) 2274 else: 2275 (data) = self.get_account_information_with_http_info(account_id, **kwargs) 2276 return data
Retrieves the account information for the specified account.
Retrieves the account information for the specified account. Response The canUpgrade property contains is a Boolean that indicates whether the account can be upgraded through the API.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_account_information(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str include_account_settings: When set to true, includes the account settings for the account in the response.
Returns
AccountInformation If the method is called asynchronously, returns the request thread.
def
get_account_information_with_http_info(self, account_id, **kwargs)
2278 def get_account_information_with_http_info(self, account_id, **kwargs): 2279 """ 2280 Retrieves the account information for the specified account. 2281 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. 2282 This method makes a synchronous HTTP request by default. To make an 2283 asynchronous HTTP request, please define a `callback` function 2284 to be invoked when receiving the response. 2285 >>> def callback_function(response): 2286 >>> pprint(response) 2287 >>> 2288 >>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function) 2289 2290 :param callback function: The callback function 2291 for asynchronous request. (optional) 2292 :param str account_id: The external account number (int) or account ID Guid. (required) 2293 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 2294 :return: AccountInformation 2295 If the method is called asynchronously, 2296 returns the request thread. 2297 """ 2298 2299 all_params = ['account_id', 'include_account_settings'] 2300 all_params.append('callback') 2301 all_params.append('_return_http_data_only') 2302 all_params.append('_preload_content') 2303 all_params.append('_request_timeout') 2304 2305 params = locals() 2306 for key, val in iteritems(params['kwargs']): 2307 if key not in all_params: 2308 raise TypeError( 2309 "Got an unexpected keyword argument '%s'" 2310 " to method get_account_information" % key 2311 ) 2312 params[key] = val 2313 del params['kwargs'] 2314 # verify the required parameter 'account_id' is set 2315 if ('account_id' not in params) or (params['account_id'] is None): 2316 raise ValueError("Missing the required parameter `account_id` when calling `get_account_information`") 2317 2318 2319 collection_formats = {} 2320 2321 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 2322 path_params = {} 2323 if 'account_id' in params: 2324 path_params['accountId'] = params['account_id'] 2325 2326 query_params = {} 2327 if 'include_account_settings' in params: 2328 query_params['include_account_settings'] = params['include_account_settings'] 2329 2330 header_params = {} 2331 2332 form_params = [] 2333 local_var_files = {} 2334 2335 body_params = None 2336 # HTTP header `Accept` 2337 header_params['Accept'] = self.api_client.\ 2338 select_header_accept(['application/json']) 2339 2340 # Authentication setting 2341 auth_settings = [] 2342 2343 return self.api_client.call_api(resource_path, 'GET', 2344 path_params, 2345 query_params, 2346 header_params, 2347 body=body_params, 2348 post_params=form_params, 2349 files=local_var_files, 2350 response_type='AccountInformation', 2351 auth_settings=auth_settings, 2352 callback=params.get('callback'), 2353 _return_http_data_only=params.get('_return_http_data_only'), 2354 _preload_content=params.get('_preload_content', True), 2355 _request_timeout=params.get('_request_timeout'), 2356 collection_formats=collection_formats)
Retrieves the account information for the specified account.
Retrieves the account information for the specified account. Response The canUpgrade property contains is a Boolean that indicates whether the account can be upgraded through the API.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str include_account_settings: When set to true, includes the account settings for the account in the response.
Returns
AccountInformation If the method is called asynchronously, returns the request thread.
def
get_account_signature(self, account_id, signature_id, **kwargs)
2358 def get_account_signature(self, account_id, signature_id, **kwargs): 2359 """ 2360 Returns information about a single signature by specifed signatureId. 2361 2362 This method makes a synchronous HTTP request by default. To make an 2363 asynchronous HTTP request, please define a `callback` function 2364 to be invoked when receiving the response. 2365 >>> def callback_function(response): 2366 >>> pprint(response) 2367 >>> 2368 >>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function) 2369 2370 :param callback function: The callback function 2371 for asynchronous request. (optional) 2372 :param str account_id: The external account number (int) or account ID Guid. (required) 2373 :param str signature_id: The ID of the signature being accessed. (required) 2374 :return: AccountSignature 2375 If the method is called asynchronously, 2376 returns the request thread. 2377 """ 2378 kwargs['_return_http_data_only'] = True 2379 if kwargs.get('callback'): 2380 return self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2381 else: 2382 (data) = self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 2383 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)
2385 def get_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 2386 """ 2387 Returns information about a single signature by specifed signatureId. 2388 2389 This method makes a synchronous HTTP request by default. To make an 2390 asynchronous HTTP request, please define a `callback` function 2391 to be invoked when receiving the response. 2392 >>> def callback_function(response): 2393 >>> pprint(response) 2394 >>> 2395 >>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 2396 2397 :param callback function: The callback function 2398 for asynchronous request. (optional) 2399 :param str account_id: The external account number (int) or account ID Guid. (required) 2400 :param str signature_id: The ID of the signature being accessed. (required) 2401 :return: AccountSignature 2402 If the method is called asynchronously, 2403 returns the request thread. 2404 """ 2405 2406 all_params = ['account_id', 'signature_id'] 2407 all_params.append('callback') 2408 all_params.append('_return_http_data_only') 2409 all_params.append('_preload_content') 2410 all_params.append('_request_timeout') 2411 2412 params = locals() 2413 for key, val in iteritems(params['kwargs']): 2414 if key not in all_params: 2415 raise TypeError( 2416 "Got an unexpected keyword argument '%s'" 2417 " to method get_account_signature" % key 2418 ) 2419 params[key] = val 2420 del params['kwargs'] 2421 # verify the required parameter 'account_id' is set 2422 if ('account_id' not in params) or (params['account_id'] is None): 2423 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature`") 2424 # verify the required parameter 'signature_id' is set 2425 if ('signature_id' not in params) or (params['signature_id'] is None): 2426 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature`") 2427 2428 2429 collection_formats = {} 2430 2431 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 2432 path_params = {} 2433 if 'account_id' in params: 2434 path_params['accountId'] = params['account_id'] 2435 if 'signature_id' in params: 2436 path_params['signatureId'] = params['signature_id'] 2437 2438 query_params = {} 2439 2440 header_params = {} 2441 2442 form_params = [] 2443 local_var_files = {} 2444 2445 body_params = None 2446 # HTTP header `Accept` 2447 header_params['Accept'] = self.api_client.\ 2448 select_header_accept(['application/json']) 2449 2450 # Authentication setting 2451 auth_settings = [] 2452 2453 return self.api_client.call_api(resource_path, 'GET', 2454 path_params, 2455 query_params, 2456 header_params, 2457 body=body_params, 2458 post_params=form_params, 2459 files=local_var_files, 2460 response_type='AccountSignature', 2461 auth_settings=auth_settings, 2462 callback=params.get('callback'), 2463 _return_http_data_only=params.get('_return_http_data_only'), 2464 _preload_content=params.get('_preload_content', True), 2465 _request_timeout=params.get('_request_timeout'), 2466 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)
2468 def get_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 2469 """ 2470 Returns a signature, initials, or stamps image. 2471 2472 This method makes a synchronous HTTP request by default. To make an 2473 asynchronous HTTP request, please define a `callback` function 2474 to be invoked when receiving the response. 2475 >>> def callback_function(response): 2476 >>> pprint(response) 2477 >>> 2478 >>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 2479 2480 :param callback function: The callback function 2481 for asynchronous request. (optional) 2482 :param str account_id: The external account number (int) or account ID Guid. (required) 2483 :param str image_type: One of **signature_image** or **initials_image**. (required) 2484 :param str signature_id: The ID of the signature being accessed. (required) 2485 :param str include_chrome: 2486 :return: file 2487 If the method is called asynchronously, 2488 returns the request thread. 2489 """ 2490 kwargs['_return_http_data_only'] = True 2491 if kwargs.get('callback'): 2492 return self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2493 else: 2494 (data) = self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2495 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)
2497 def get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 2498 """ 2499 Returns a signature, initials, or stamps image. 2500 2501 This method makes a synchronous HTTP request by default. To make an 2502 asynchronous HTTP request, please define a `callback` function 2503 to be invoked when receiving the response. 2504 >>> def callback_function(response): 2505 >>> pprint(response) 2506 >>> 2507 >>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 2508 2509 :param callback function: The callback function 2510 for asynchronous request. (optional) 2511 :param str account_id: The external account number (int) or account ID Guid. (required) 2512 :param str image_type: One of **signature_image** or **initials_image**. (required) 2513 :param str signature_id: The ID of the signature being accessed. (required) 2514 :param str include_chrome: 2515 :return: file 2516 If the method is called asynchronously, 2517 returns the request thread. 2518 """ 2519 2520 all_params = ['account_id', 'image_type', 'signature_id', 'include_chrome'] 2521 all_params.append('callback') 2522 all_params.append('_return_http_data_only') 2523 all_params.append('_preload_content') 2524 all_params.append('_request_timeout') 2525 2526 params = locals() 2527 for key, val in iteritems(params['kwargs']): 2528 if key not in all_params: 2529 raise TypeError( 2530 "Got an unexpected keyword argument '%s'" 2531 " to method get_account_signature_image" % key 2532 ) 2533 params[key] = val 2534 del params['kwargs'] 2535 # verify the required parameter 'account_id' is set 2536 if ('account_id' not in params) or (params['account_id'] is None): 2537 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature_image`") 2538 # verify the required parameter 'image_type' is set 2539 if ('image_type' not in params) or (params['image_type'] is None): 2540 raise ValueError("Missing the required parameter `image_type` when calling `get_account_signature_image`") 2541 # verify the required parameter 'signature_id' is set 2542 if ('signature_id' not in params) or (params['signature_id'] is None): 2543 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature_image`") 2544 2545 2546 collection_formats = {} 2547 2548 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 2549 path_params = {} 2550 if 'account_id' in params: 2551 path_params['accountId'] = params['account_id'] 2552 if 'image_type' in params: 2553 path_params['imageType'] = params['image_type'] 2554 if 'signature_id' in params: 2555 path_params['signatureId'] = params['signature_id'] 2556 2557 query_params = {} 2558 if 'include_chrome' in params: 2559 query_params['include_chrome'] = params['include_chrome'] 2560 2561 header_params = {} 2562 2563 form_params = [] 2564 local_var_files = {} 2565 2566 body_params = None 2567 # HTTP header `Accept` 2568 header_params['Accept'] = self.api_client.\ 2569 select_header_accept(['image/gif']) 2570 2571 # Authentication setting 2572 auth_settings = [] 2573 2574 return self.api_client.call_api(resource_path, 'GET', 2575 path_params, 2576 query_params, 2577 header_params, 2578 body=body_params, 2579 post_params=form_params, 2580 files=local_var_files, 2581 response_type='file', 2582 auth_settings=auth_settings, 2583 callback=params.get('callback'), 2584 _return_http_data_only=params.get('_return_http_data_only'), 2585 _preload_content=params.get('_preload_content', True), 2586 _request_timeout=params.get('_request_timeout'), 2587 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)
2589 def get_account_signatures(self, account_id, **kwargs): 2590 """ 2591 Returns the managed signature definitions for the account 2592 2593 This method makes a synchronous HTTP request by default. To make an 2594 asynchronous HTTP request, please define a `callback` function 2595 to be invoked when receiving the response. 2596 >>> def callback_function(response): 2597 >>> pprint(response) 2598 >>> 2599 >>> thread = api.get_account_signatures(account_id, callback=callback_function) 2600 2601 :param callback function: The callback function 2602 for asynchronous request. (optional) 2603 :param str account_id: The external account number (int) or account ID Guid. (required) 2604 :param str stamp_format: 2605 :param str stamp_name: 2606 :param str stamp_type: 2607 :return: AccountSignaturesInformation 2608 If the method is called asynchronously, 2609 returns the request thread. 2610 """ 2611 kwargs['_return_http_data_only'] = True 2612 if kwargs.get('callback'): 2613 return self.get_account_signatures_with_http_info(account_id, **kwargs) 2614 else: 2615 (data) = self.get_account_signatures_with_http_info(account_id, **kwargs) 2616 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)
2618 def get_account_signatures_with_http_info(self, account_id, **kwargs): 2619 """ 2620 Returns the managed signature definitions for the account 2621 2622 This method makes a synchronous HTTP request by default. To make an 2623 asynchronous HTTP request, please define a `callback` function 2624 to be invoked when receiving the response. 2625 >>> def callback_function(response): 2626 >>> pprint(response) 2627 >>> 2628 >>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function) 2629 2630 :param callback function: The callback function 2631 for asynchronous request. (optional) 2632 :param str account_id: The external account number (int) or account ID Guid. (required) 2633 :param str stamp_format: 2634 :param str stamp_name: 2635 :param str stamp_type: 2636 :return: AccountSignaturesInformation 2637 If the method is called asynchronously, 2638 returns the request thread. 2639 """ 2640 2641 all_params = ['account_id', 'stamp_format', 'stamp_name', 'stamp_type'] 2642 all_params.append('callback') 2643 all_params.append('_return_http_data_only') 2644 all_params.append('_preload_content') 2645 all_params.append('_request_timeout') 2646 2647 params = locals() 2648 for key, val in iteritems(params['kwargs']): 2649 if key not in all_params: 2650 raise TypeError( 2651 "Got an unexpected keyword argument '%s'" 2652 " to method get_account_signatures" % key 2653 ) 2654 params[key] = val 2655 del params['kwargs'] 2656 # verify the required parameter 'account_id' is set 2657 if ('account_id' not in params) or (params['account_id'] is None): 2658 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signatures`") 2659 2660 2661 collection_formats = {} 2662 2663 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 2664 path_params = {} 2665 if 'account_id' in params: 2666 path_params['accountId'] = params['account_id'] 2667 2668 query_params = {} 2669 if 'stamp_format' in params: 2670 query_params['stamp_format'] = params['stamp_format'] 2671 if 'stamp_name' in params: 2672 query_params['stamp_name'] = params['stamp_name'] 2673 if 'stamp_type' in params: 2674 query_params['stamp_type'] = params['stamp_type'] 2675 2676 header_params = {} 2677 2678 form_params = [] 2679 local_var_files = {} 2680 2681 body_params = None 2682 # HTTP header `Accept` 2683 header_params['Accept'] = self.api_client.\ 2684 select_header_accept(['application/json']) 2685 2686 # Authentication setting 2687 auth_settings = [] 2688 2689 return self.api_client.call_api(resource_path, 'GET', 2690 path_params, 2691 query_params, 2692 header_params, 2693 body=body_params, 2694 post_params=form_params, 2695 files=local_var_files, 2696 response_type='AccountSignaturesInformation', 2697 auth_settings=auth_settings, 2698 callback=params.get('callback'), 2699 _return_http_data_only=params.get('_return_http_data_only'), 2700 _preload_content=params.get('_preload_content', True), 2701 _request_timeout=params.get('_request_timeout'), 2702 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)
2704 def get_account_tab_settings(self, account_id, **kwargs): 2705 """ 2706 Returns tab settings list for specified account 2707 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2708 This method makes a synchronous HTTP request by default. To make an 2709 asynchronous HTTP request, please define a `callback` function 2710 to be invoked when receiving the response. 2711 >>> def callback_function(response): 2712 >>> pprint(response) 2713 >>> 2714 >>> thread = api.get_account_tab_settings(account_id, callback=callback_function) 2715 2716 :param callback function: The callback function 2717 for asynchronous request. (optional) 2718 :param str account_id: The external account number (int) or account ID Guid. (required) 2719 :return: TabAccountSettings 2720 If the method is called asynchronously, 2721 returns the request thread. 2722 """ 2723 kwargs['_return_http_data_only'] = True 2724 if kwargs.get('callback'): 2725 return self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2726 else: 2727 (data) = self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2728 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)
2730 def get_account_tab_settings_with_http_info(self, account_id, **kwargs): 2731 """ 2732 Returns tab settings list for specified account 2733 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2734 This method makes a synchronous HTTP request by default. To make an 2735 asynchronous HTTP request, please define a `callback` function 2736 to be invoked when receiving the response. 2737 >>> def callback_function(response): 2738 >>> pprint(response) 2739 >>> 2740 >>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function) 2741 2742 :param callback function: The callback function 2743 for asynchronous request. (optional) 2744 :param str account_id: The external account number (int) or account ID Guid. (required) 2745 :return: TabAccountSettings 2746 If the method is called asynchronously, 2747 returns the request thread. 2748 """ 2749 2750 all_params = ['account_id'] 2751 all_params.append('callback') 2752 all_params.append('_return_http_data_only') 2753 all_params.append('_preload_content') 2754 all_params.append('_request_timeout') 2755 2756 params = locals() 2757 for key, val in iteritems(params['kwargs']): 2758 if key not in all_params: 2759 raise TypeError( 2760 "Got an unexpected keyword argument '%s'" 2761 " to method get_account_tab_settings" % key 2762 ) 2763 params[key] = val 2764 del params['kwargs'] 2765 # verify the required parameter 'account_id' is set 2766 if ('account_id' not in params) or (params['account_id'] is None): 2767 raise ValueError("Missing the required parameter `account_id` when calling `get_account_tab_settings`") 2768 2769 2770 collection_formats = {} 2771 2772 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 2773 path_params = {} 2774 if 'account_id' in params: 2775 path_params['accountId'] = params['account_id'] 2776 2777 query_params = {} 2778 2779 header_params = {} 2780 2781 form_params = [] 2782 local_var_files = {} 2783 2784 body_params = None 2785 # HTTP header `Accept` 2786 header_params['Accept'] = self.api_client.\ 2787 select_header_accept(['application/json']) 2788 2789 # Authentication setting 2790 auth_settings = [] 2791 2792 return self.api_client.call_api(resource_path, 'GET', 2793 path_params, 2794 query_params, 2795 header_params, 2796 body=body_params, 2797 post_params=form_params, 2798 files=local_var_files, 2799 response_type='TabAccountSettings', 2800 auth_settings=auth_settings, 2801 callback=params.get('callback'), 2802 _return_http_data_only=params.get('_return_http_data_only'), 2803 _preload_content=params.get('_preload_content', True), 2804 _request_timeout=params.get('_request_timeout'), 2805 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)
2943 def get_all_payment_gateway_accounts(self, account_id, **kwargs): 2944 """ 2945 Get all payment gateway account for the provided accountId 2946 This method returns a list of payment gateway accounts and basic information about them. 2947 This method makes a synchronous HTTP request by default. To make an 2948 asynchronous HTTP request, please define a `callback` function 2949 to be invoked when receiving the response. 2950 >>> def callback_function(response): 2951 >>> pprint(response) 2952 >>> 2953 >>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function) 2954 2955 :param callback function: The callback function 2956 for asynchronous request. (optional) 2957 :param str account_id: The external account number (int) or account ID Guid. (required) 2958 :return: PaymentGatewayAccountsInfo 2959 If the method is called asynchronously, 2960 returns the request thread. 2961 """ 2962 kwargs['_return_http_data_only'] = True 2963 if kwargs.get('callback'): 2964 return self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2965 else: 2966 (data) = self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2967 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)
2969 def get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs): 2970 """ 2971 Get all payment gateway account for the provided accountId 2972 This method returns a list of payment gateway accounts and basic information about them. 2973 This method makes a synchronous HTTP request by default. To make an 2974 asynchronous HTTP request, please define a `callback` function 2975 to be invoked when receiving the response. 2976 >>> def callback_function(response): 2977 >>> pprint(response) 2978 >>> 2979 >>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function) 2980 2981 :param callback function: The callback function 2982 for asynchronous request. (optional) 2983 :param str account_id: The external account number (int) or account ID Guid. (required) 2984 :return: PaymentGatewayAccountsInfo 2985 If the method is called asynchronously, 2986 returns the request thread. 2987 """ 2988 2989 all_params = ['account_id'] 2990 all_params.append('callback') 2991 all_params.append('_return_http_data_only') 2992 all_params.append('_preload_content') 2993 all_params.append('_request_timeout') 2994 2995 params = locals() 2996 for key, val in iteritems(params['kwargs']): 2997 if key not in all_params: 2998 raise TypeError( 2999 "Got an unexpected keyword argument '%s'" 3000 " to method get_all_payment_gateway_accounts" % key 3001 ) 3002 params[key] = val 3003 del params['kwargs'] 3004 # verify the required parameter 'account_id' is set 3005 if ('account_id' not in params) or (params['account_id'] is None): 3006 raise ValueError("Missing the required parameter `account_id` when calling `get_all_payment_gateway_accounts`") 3007 3008 3009 collection_formats = {} 3010 3011 resource_path = '/v2.1/accounts/{accountId}/payment_gateway_accounts'.replace('{format}', 'json') 3012 path_params = {} 3013 if 'account_id' in params: 3014 path_params['accountId'] = params['account_id'] 3015 3016 query_params = {} 3017 3018 header_params = {} 3019 3020 form_params = [] 3021 local_var_files = {} 3022 3023 body_params = None 3024 # HTTP header `Accept` 3025 header_params['Accept'] = self.api_client.\ 3026 select_header_accept(['application/json']) 3027 3028 # Authentication setting 3029 auth_settings = [] 3030 3031 return self.api_client.call_api(resource_path, 'GET', 3032 path_params, 3033 query_params, 3034 header_params, 3035 body=body_params, 3036 post_params=form_params, 3037 files=local_var_files, 3038 response_type='PaymentGatewayAccountsInfo', 3039 auth_settings=auth_settings, 3040 callback=params.get('callback'), 3041 _return_http_data_only=params.get('_return_http_data_only'), 3042 _preload_content=params.get('_preload_content', True), 3043 _request_timeout=params.get('_request_timeout'), 3044 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)
3046 def get_billing_charges(self, account_id, **kwargs): 3047 """ 3048 Gets list of recurring and usage charges for the account. 3049 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 3050 This method makes a synchronous HTTP request by default. To make an 3051 asynchronous HTTP request, please define a `callback` function 3052 to be invoked when receiving the response. 3053 >>> def callback_function(response): 3054 >>> pprint(response) 3055 >>> 3056 >>> thread = api.get_billing_charges(account_id, callback=callback_function) 3057 3058 :param callback function: The callback function 3059 for asynchronous request. (optional) 3060 :param str account_id: The external account number (int) or account ID Guid. (required) 3061 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3062 :return: BillingChargeResponse 3063 If the method is called asynchronously, 3064 returns the request thread. 3065 """ 3066 kwargs['_return_http_data_only'] = True 3067 if kwargs.get('callback'): 3068 return self.get_billing_charges_with_http_info(account_id, **kwargs) 3069 else: 3070 (data) = self.get_billing_charges_with_http_info(account_id, **kwargs) 3071 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)
3073 def get_billing_charges_with_http_info(self, account_id, **kwargs): 3074 """ 3075 Gets list of recurring and usage charges for the account. 3076 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 3077 This method makes a synchronous HTTP request by default. To make an 3078 asynchronous HTTP request, please define a `callback` function 3079 to be invoked when receiving the response. 3080 >>> def callback_function(response): 3081 >>> pprint(response) 3082 >>> 3083 >>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function) 3084 3085 :param callback function: The callback function 3086 for asynchronous request. (optional) 3087 :param str account_id: The external account number (int) or account ID Guid. (required) 3088 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 3089 :return: BillingChargeResponse 3090 If the method is called asynchronously, 3091 returns the request thread. 3092 """ 3093 3094 all_params = ['account_id', 'include_charges'] 3095 all_params.append('callback') 3096 all_params.append('_return_http_data_only') 3097 all_params.append('_preload_content') 3098 all_params.append('_request_timeout') 3099 3100 params = locals() 3101 for key, val in iteritems(params['kwargs']): 3102 if key not in all_params: 3103 raise TypeError( 3104 "Got an unexpected keyword argument '%s'" 3105 " to method get_billing_charges" % key 3106 ) 3107 params[key] = val 3108 del params['kwargs'] 3109 # verify the required parameter 'account_id' is set 3110 if ('account_id' not in params) or (params['account_id'] is None): 3111 raise ValueError("Missing the required parameter `account_id` when calling `get_billing_charges`") 3112 3113 3114 collection_formats = {} 3115 3116 resource_path = '/v2.1/accounts/{accountId}/billing_charges'.replace('{format}', 'json') 3117 path_params = {} 3118 if 'account_id' in params: 3119 path_params['accountId'] = params['account_id'] 3120 3121 query_params = {} 3122 if 'include_charges' in params: 3123 query_params['include_charges'] = params['include_charges'] 3124 3125 header_params = {} 3126 3127 form_params = [] 3128 local_var_files = {} 3129 3130 body_params = None 3131 # HTTP header `Accept` 3132 header_params['Accept'] = self.api_client.\ 3133 select_header_accept(['application/json']) 3134 3135 # Authentication setting 3136 auth_settings = [] 3137 3138 return self.api_client.call_api(resource_path, 'GET', 3139 path_params, 3140 query_params, 3141 header_params, 3142 body=body_params, 3143 post_params=form_params, 3144 files=local_var_files, 3145 response_type='BillingChargeResponse', 3146 auth_settings=auth_settings, 3147 callback=params.get('callback'), 3148 _return_http_data_only=params.get('_return_http_data_only'), 3149 _preload_content=params.get('_preload_content', True), 3150 _request_timeout=params.get('_request_timeout'), 3151 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)
3153 def get_brand(self, account_id, brand_id, **kwargs): 3154 """ 3155 Get information for a specific brand. 3156 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**). 3157 This method makes a synchronous HTTP request by default. To make an 3158 asynchronous HTTP request, please define a `callback` function 3159 to be invoked when receiving the response. 3160 >>> def callback_function(response): 3161 >>> pprint(response) 3162 >>> 3163 >>> thread = api.get_brand(account_id, brand_id, callback=callback_function) 3164 3165 :param callback function: The callback function 3166 for asynchronous request. (optional) 3167 :param str account_id: The external account number (int) or account ID Guid. (required) 3168 :param str brand_id: The unique identifier of a brand. (required) 3169 :param str include_external_references: 3170 :param str include_logos: 3171 :return: Brand 3172 If the method is called asynchronously, 3173 returns the request thread. 3174 """ 3175 kwargs['_return_http_data_only'] = True 3176 if kwargs.get('callback'): 3177 return self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3178 else: 3179 (data) = self.get_brand_with_http_info(account_id, brand_id, **kwargs) 3180 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)
3182 def get_brand_with_http_info(self, account_id, brand_id, **kwargs): 3183 """ 3184 Get information for a specific brand. 3185 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**). 3186 This method makes a synchronous HTTP request by default. To make an 3187 asynchronous HTTP request, please define a `callback` function 3188 to be invoked when receiving the response. 3189 >>> def callback_function(response): 3190 >>> pprint(response) 3191 >>> 3192 >>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function) 3193 3194 :param callback function: The callback function 3195 for asynchronous request. (optional) 3196 :param str account_id: The external account number (int) or account ID Guid. (required) 3197 :param str brand_id: The unique identifier of a brand. (required) 3198 :param str include_external_references: 3199 :param str include_logos: 3200 :return: Brand 3201 If the method is called asynchronously, 3202 returns the request thread. 3203 """ 3204 3205 all_params = ['account_id', 'brand_id', 'include_external_references', 'include_logos'] 3206 all_params.append('callback') 3207 all_params.append('_return_http_data_only') 3208 all_params.append('_preload_content') 3209 all_params.append('_request_timeout') 3210 3211 params = locals() 3212 for key, val in iteritems(params['kwargs']): 3213 if key not in all_params: 3214 raise TypeError( 3215 "Got an unexpected keyword argument '%s'" 3216 " to method get_brand" % key 3217 ) 3218 params[key] = val 3219 del params['kwargs'] 3220 # verify the required parameter 'account_id' is set 3221 if ('account_id' not in params) or (params['account_id'] is None): 3222 raise ValueError("Missing the required parameter `account_id` when calling `get_brand`") 3223 # verify the required parameter 'brand_id' is set 3224 if ('brand_id' not in params) or (params['brand_id'] is None): 3225 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand`") 3226 3227 3228 collection_formats = {} 3229 3230 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 3231 path_params = {} 3232 if 'account_id' in params: 3233 path_params['accountId'] = params['account_id'] 3234 if 'brand_id' in params: 3235 path_params['brandId'] = params['brand_id'] 3236 3237 query_params = {} 3238 if 'include_external_references' in params: 3239 query_params['include_external_references'] = params['include_external_references'] 3240 if 'include_logos' in params: 3241 query_params['include_logos'] = params['include_logos'] 3242 3243 header_params = {} 3244 3245 form_params = [] 3246 local_var_files = {} 3247 3248 body_params = None 3249 # HTTP header `Accept` 3250 header_params['Accept'] = self.api_client.\ 3251 select_header_accept(['application/json']) 3252 3253 # Authentication setting 3254 auth_settings = [] 3255 3256 return self.api_client.call_api(resource_path, 'GET', 3257 path_params, 3258 query_params, 3259 header_params, 3260 body=body_params, 3261 post_params=form_params, 3262 files=local_var_files, 3263 response_type='Brand', 3264 auth_settings=auth_settings, 3265 callback=params.get('callback'), 3266 _return_http_data_only=params.get('_return_http_data_only'), 3267 _preload_content=params.get('_preload_content', True), 3268 _request_timeout=params.get('_request_timeout'), 3269 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)
3271 def get_brand_export_file(self, account_id, brand_id, **kwargs): 3272 """ 3273 Export a specific brand. 3274 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**). 3275 This method makes a synchronous HTTP request by default. To make an 3276 asynchronous HTTP request, please define a `callback` function 3277 to be invoked when receiving the response. 3278 >>> def callback_function(response): 3279 >>> pprint(response) 3280 >>> 3281 >>> thread = api.get_brand_export_file(account_id, brand_id, callback=callback_function) 3282 3283 :param callback function: The callback function 3284 for asynchronous request. (optional) 3285 :param str account_id: The external account number (int) or account ID Guid. (required) 3286 :param str brand_id: The unique identifier of a brand. (required) 3287 :return: None 3288 If the method is called asynchronously, 3289 returns the request thread. 3290 """ 3291 kwargs['_return_http_data_only'] = True 3292 if kwargs.get('callback'): 3293 return self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3294 else: 3295 (data) = self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 3296 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)
3298 def get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs): 3299 """ 3300 Export a specific brand. 3301 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**). 3302 This method makes a synchronous HTTP request by default. To make an 3303 asynchronous HTTP request, please define a `callback` function 3304 to be invoked when receiving the response. 3305 >>> def callback_function(response): 3306 >>> pprint(response) 3307 >>> 3308 >>> thread = api.get_brand_export_file_with_http_info(account_id, brand_id, callback=callback_function) 3309 3310 :param callback function: The callback function 3311 for asynchronous request. (optional) 3312 :param str account_id: The external account number (int) or account ID Guid. (required) 3313 :param str brand_id: The unique identifier of a brand. (required) 3314 :return: None 3315 If the method is called asynchronously, 3316 returns the request thread. 3317 """ 3318 3319 all_params = ['account_id', 'brand_id'] 3320 all_params.append('callback') 3321 all_params.append('_return_http_data_only') 3322 all_params.append('_preload_content') 3323 all_params.append('_request_timeout') 3324 3325 params = locals() 3326 for key, val in iteritems(params['kwargs']): 3327 if key not in all_params: 3328 raise TypeError( 3329 "Got an unexpected keyword argument '%s'" 3330 " to method get_brand_export_file" % key 3331 ) 3332 params[key] = val 3333 del params['kwargs'] 3334 # verify the required parameter 'account_id' is set 3335 if ('account_id' not in params) or (params['account_id'] is None): 3336 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_export_file`") 3337 # verify the required parameter 'brand_id' is set 3338 if ('brand_id' not in params) or (params['brand_id'] is None): 3339 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_export_file`") 3340 3341 3342 collection_formats = {} 3343 3344 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/file'.replace('{format}', 'json') 3345 path_params = {} 3346 if 'account_id' in params: 3347 path_params['accountId'] = params['account_id'] 3348 if 'brand_id' in params: 3349 path_params['brandId'] = params['brand_id'] 3350 3351 query_params = {} 3352 3353 header_params = {} 3354 3355 form_params = [] 3356 local_var_files = {} 3357 3358 body_params = None 3359 # HTTP header `Accept` 3360 header_params['Accept'] = self.api_client.\ 3361 select_header_accept(['application/json']) 3362 3363 # Authentication setting 3364 auth_settings = [] 3365 3366 return self.api_client.call_api(resource_path, 'GET', 3367 path_params, 3368 query_params, 3369 header_params, 3370 body=body_params, 3371 post_params=form_params, 3372 files=local_var_files, 3373 response_type=None, 3374 auth_settings=auth_settings, 3375 callback=params.get('callback'), 3376 _return_http_data_only=params.get('_return_http_data_only'), 3377 _preload_content=params.get('_preload_content', True), 3378 _request_timeout=params.get('_request_timeout'), 3379 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)
3381 def get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 3382 """ 3383 Obtains the specified image for a brand. 3384 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**). 3385 This method makes a synchronous HTTP request by default. To make an 3386 asynchronous HTTP request, please define a `callback` function 3387 to be invoked when receiving the response. 3388 >>> def callback_function(response): 3389 >>> pprint(response) 3390 >>> 3391 >>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 3392 3393 :param callback function: The callback function 3394 for asynchronous request. (optional) 3395 :param str account_id: The external account number (int) or account ID Guid. (required) 3396 :param str brand_id: The unique identifier of a brand. (required) 3397 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3398 :return: file 3399 If the method is called asynchronously, 3400 returns the request thread. 3401 """ 3402 kwargs['_return_http_data_only'] = True 3403 if kwargs.get('callback'): 3404 return self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3405 else: 3406 (data) = self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 3407 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)
3409 def get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 3410 """ 3411 Obtains the specified image for a brand. 3412 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**). 3413 This method makes a synchronous HTTP request by default. To make an 3414 asynchronous HTTP request, please define a `callback` function 3415 to be invoked when receiving the response. 3416 >>> def callback_function(response): 3417 >>> pprint(response) 3418 >>> 3419 >>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 3420 3421 :param callback function: The callback function 3422 for asynchronous request. (optional) 3423 :param str account_id: The external account number (int) or account ID Guid. (required) 3424 :param str brand_id: The unique identifier of a brand. (required) 3425 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 3426 :return: file 3427 If the method is called asynchronously, 3428 returns the request thread. 3429 """ 3430 3431 all_params = ['account_id', 'brand_id', 'logo_type'] 3432 all_params.append('callback') 3433 all_params.append('_return_http_data_only') 3434 all_params.append('_preload_content') 3435 all_params.append('_request_timeout') 3436 3437 params = locals() 3438 for key, val in iteritems(params['kwargs']): 3439 if key not in all_params: 3440 raise TypeError( 3441 "Got an unexpected keyword argument '%s'" 3442 " to method get_brand_logo_by_type" % key 3443 ) 3444 params[key] = val 3445 del params['kwargs'] 3446 # verify the required parameter 'account_id' is set 3447 if ('account_id' not in params) or (params['account_id'] is None): 3448 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_logo_by_type`") 3449 # verify the required parameter 'brand_id' is set 3450 if ('brand_id' not in params) or (params['brand_id'] is None): 3451 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_logo_by_type`") 3452 # verify the required parameter 'logo_type' is set 3453 if ('logo_type' not in params) or (params['logo_type'] is None): 3454 raise ValueError("Missing the required parameter `logo_type` when calling `get_brand_logo_by_type`") 3455 3456 3457 collection_formats = {} 3458 3459 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 3460 path_params = {} 3461 if 'account_id' in params: 3462 path_params['accountId'] = params['account_id'] 3463 if 'brand_id' in params: 3464 path_params['brandId'] = params['brand_id'] 3465 if 'logo_type' in params: 3466 path_params['logoType'] = params['logo_type'] 3467 3468 query_params = {} 3469 3470 header_params = {} 3471 3472 form_params = [] 3473 local_var_files = {} 3474 3475 body_params = None 3476 # HTTP header `Accept` 3477 header_params['Accept'] = self.api_client.\ 3478 select_header_accept(['image/png']) 3479 3480 # Authentication setting 3481 auth_settings = [] 3482 3483 return self.api_client.call_api(resource_path, 'GET', 3484 path_params, 3485 query_params, 3486 header_params, 3487 body=body_params, 3488 post_params=form_params, 3489 files=local_var_files, 3490 response_type='file', 3491 auth_settings=auth_settings, 3492 callback=params.get('callback'), 3493 _return_http_data_only=params.get('_return_http_data_only'), 3494 _preload_content=params.get('_preload_content', True), 3495 _request_timeout=params.get('_request_timeout'), 3496 collection_formats=collection_formats)
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)
3498 def get_brand_resources(self, account_id, brand_id, **kwargs): 3499 """ 3500 Returns the specified account's list of branding resources (metadata). 3501 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**). 3502 This method makes a synchronous HTTP request by default. To make an 3503 asynchronous HTTP request, please define a `callback` function 3504 to be invoked when receiving the response. 3505 >>> def callback_function(response): 3506 >>> pprint(response) 3507 >>> 3508 >>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function) 3509 3510 :param callback function: The callback function 3511 for asynchronous request. (optional) 3512 :param str account_id: The external account number (int) or account ID Guid. (required) 3513 :param str brand_id: The unique identifier of a brand. (required) 3514 :return: BrandResourcesList 3515 If the method is called asynchronously, 3516 returns the request thread. 3517 """ 3518 kwargs['_return_http_data_only'] = True 3519 if kwargs.get('callback'): 3520 return self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3521 else: 3522 (data) = self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 3523 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)
3525 def get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs): 3526 """ 3527 Returns the specified account's list of branding resources (metadata). 3528 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**). 3529 This method makes a synchronous HTTP request by default. To make an 3530 asynchronous HTTP request, please define a `callback` function 3531 to be invoked when receiving the response. 3532 >>> def callback_function(response): 3533 >>> pprint(response) 3534 >>> 3535 >>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function) 3536 3537 :param callback function: The callback function 3538 for asynchronous request. (optional) 3539 :param str account_id: The external account number (int) or account ID Guid. (required) 3540 :param str brand_id: The unique identifier of a brand. (required) 3541 :return: BrandResourcesList 3542 If the method is called asynchronously, 3543 returns the request thread. 3544 """ 3545 3546 all_params = ['account_id', 'brand_id'] 3547 all_params.append('callback') 3548 all_params.append('_return_http_data_only') 3549 all_params.append('_preload_content') 3550 all_params.append('_request_timeout') 3551 3552 params = locals() 3553 for key, val in iteritems(params['kwargs']): 3554 if key not in all_params: 3555 raise TypeError( 3556 "Got an unexpected keyword argument '%s'" 3557 " to method get_brand_resources" % key 3558 ) 3559 params[key] = val 3560 del params['kwargs'] 3561 # verify the required parameter 'account_id' is set 3562 if ('account_id' not in params) or (params['account_id'] is None): 3563 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources`") 3564 # verify the required parameter 'brand_id' is set 3565 if ('brand_id' not in params) or (params['brand_id'] is None): 3566 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources`") 3567 3568 3569 collection_formats = {} 3570 3571 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources'.replace('{format}', 'json') 3572 path_params = {} 3573 if 'account_id' in params: 3574 path_params['accountId'] = params['account_id'] 3575 if 'brand_id' in params: 3576 path_params['brandId'] = params['brand_id'] 3577 3578 query_params = {} 3579 3580 header_params = {} 3581 3582 form_params = [] 3583 local_var_files = {} 3584 3585 body_params = None 3586 # HTTP header `Accept` 3587 header_params['Accept'] = self.api_client.\ 3588 select_header_accept(['application/json']) 3589 3590 # Authentication setting 3591 auth_settings = [] 3592 3593 return self.api_client.call_api(resource_path, 'GET', 3594 path_params, 3595 query_params, 3596 header_params, 3597 body=body_params, 3598 post_params=form_params, 3599 files=local_var_files, 3600 response_type='BrandResourcesList', 3601 auth_settings=auth_settings, 3602 callback=params.get('callback'), 3603 _return_http_data_only=params.get('_return_http_data_only'), 3604 _preload_content=params.get('_preload_content', True), 3605 _request_timeout=params.get('_request_timeout'), 3606 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)
3608 def get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs): 3609 """ 3610 Returns the specified branding resource file. 3611 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**). 3612 This method makes a synchronous HTTP request by default. To make an 3613 asynchronous HTTP request, please define a `callback` function 3614 to be invoked when receiving the response. 3615 >>> def callback_function(response): 3616 >>> pprint(response) 3617 >>> 3618 >>> thread = api.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, callback=callback_function) 3619 3620 :param callback function: The callback function 3621 for asynchronous request. (optional) 3622 :param str account_id: The external account number (int) or account ID Guid. (required) 3623 :param str brand_id: The unique identifier of a brand. (required) 3624 :param str resource_content_type: (required) 3625 :param str langcode: 3626 :param str return_master: 3627 :return: None 3628 If the method is called asynchronously, 3629 returns the request thread. 3630 """ 3631 kwargs['_return_http_data_only'] = True 3632 if kwargs.get('callback'): 3633 return self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3634 else: 3635 (data) = self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3636 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)
3638 def get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs): 3639 """ 3640 Returns the specified branding resource file. 3641 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**). 3642 This method makes a synchronous HTTP request by default. To make an 3643 asynchronous HTTP request, please define a `callback` function 3644 to be invoked when receiving the response. 3645 >>> def callback_function(response): 3646 >>> pprint(response) 3647 >>> 3648 >>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function) 3649 3650 :param callback function: The callback function 3651 for asynchronous request. (optional) 3652 :param str account_id: The external account number (int) or account ID Guid. (required) 3653 :param str brand_id: The unique identifier of a brand. (required) 3654 :param str resource_content_type: (required) 3655 :param str langcode: 3656 :param str return_master: 3657 :return: None 3658 If the method is called asynchronously, 3659 returns the request thread. 3660 """ 3661 3662 all_params = ['account_id', 'brand_id', 'resource_content_type', 'langcode', 'return_master'] 3663 all_params.append('callback') 3664 all_params.append('_return_http_data_only') 3665 all_params.append('_preload_content') 3666 all_params.append('_request_timeout') 3667 3668 params = locals() 3669 for key, val in iteritems(params['kwargs']): 3670 if key not in all_params: 3671 raise TypeError( 3672 "Got an unexpected keyword argument '%s'" 3673 " to method get_brand_resources_by_content_type" % key 3674 ) 3675 params[key] = val 3676 del params['kwargs'] 3677 # verify the required parameter 'account_id' is set 3678 if ('account_id' not in params) or (params['account_id'] is None): 3679 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources_by_content_type`") 3680 # verify the required parameter 'brand_id' is set 3681 if ('brand_id' not in params) or (params['brand_id'] is None): 3682 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources_by_content_type`") 3683 # verify the required parameter 'resource_content_type' is set 3684 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 3685 raise ValueError("Missing the required parameter `resource_content_type` when calling `get_brand_resources_by_content_type`") 3686 3687 3688 collection_formats = {} 3689 3690 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 3691 path_params = {} 3692 if 'account_id' in params: 3693 path_params['accountId'] = params['account_id'] 3694 if 'brand_id' in params: 3695 path_params['brandId'] = params['brand_id'] 3696 if 'resource_content_type' in params: 3697 path_params['resourceContentType'] = params['resource_content_type'] 3698 3699 query_params = {} 3700 if 'langcode' in params: 3701 query_params['langcode'] = params['langcode'] 3702 if 'return_master' in params: 3703 query_params['return_master'] = params['return_master'] 3704 3705 header_params = {} 3706 3707 form_params = [] 3708 local_var_files = {} 3709 3710 body_params = None 3711 # HTTP header `Accept` 3712 header_params['Accept'] = self.api_client.\ 3713 select_header_accept(['application/json']) 3714 3715 # Authentication setting 3716 auth_settings = [] 3717 3718 return self.api_client.call_api(resource_path, 'GET', 3719 path_params, 3720 query_params, 3721 header_params, 3722 body=body_params, 3723 post_params=form_params, 3724 files=local_var_files, 3725 response_type=None, 3726 auth_settings=auth_settings, 3727 callback=params.get('callback'), 3728 _return_http_data_only=params.get('_return_http_data_only'), 3729 _preload_content=params.get('_preload_content', True), 3730 _request_timeout=params.get('_request_timeout'), 3731 collection_formats=collection_formats)
Returns the specified branding resource file.
This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. Important: When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str resource_content_type: (required)
- str langcode:
- str return_master:
Returns
None If the method is called asynchronously, returns the request thread.
def
get_consumer_disclosure(self, account_id, lang_code, **kwargs)
3733 def get_consumer_disclosure(self, account_id, lang_code, **kwargs): 3734 """ 3735 Gets the Electronic Record and Signature Disclosure. 3736 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. 3737 This method makes a synchronous HTTP request by default. To make an 3738 asynchronous HTTP request, please define a `callback` function 3739 to be invoked when receiving the response. 3740 >>> def callback_function(response): 3741 >>> pprint(response) 3742 >>> 3743 >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function) 3744 3745 :param callback function: The callback function 3746 for asynchronous request. (optional) 3747 :param str account_id: The external account number (int) or account ID Guid. (required) 3748 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3749 :return: ConsumerDisclosure 3750 If the method is called asynchronously, 3751 returns the request thread. 3752 """ 3753 kwargs['_return_http_data_only'] = True 3754 if kwargs.get('callback'): 3755 return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3756 else: 3757 (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3758 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), 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)
3760 def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 3761 """ 3762 Gets the Electronic Record and Signature Disclosure. 3763 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. 3764 This method makes a synchronous HTTP request by default. To make an 3765 asynchronous HTTP request, please define a `callback` function 3766 to be invoked when receiving the response. 3767 >>> def callback_function(response): 3768 >>> pprint(response) 3769 >>> 3770 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 3771 3772 :param callback function: The callback function 3773 for asynchronous request. (optional) 3774 :param str account_id: The external account number (int) or account ID Guid. (required) 3775 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3776 :return: ConsumerDisclosure 3777 If the method is called asynchronously, 3778 returns the request thread. 3779 """ 3780 3781 all_params = ['account_id', 'lang_code'] 3782 all_params.append('callback') 3783 all_params.append('_return_http_data_only') 3784 all_params.append('_preload_content') 3785 all_params.append('_request_timeout') 3786 3787 params = locals() 3788 for key, val in iteritems(params['kwargs']): 3789 if key not in all_params: 3790 raise TypeError( 3791 "Got an unexpected keyword argument '%s'" 3792 " to method get_consumer_disclosure" % key 3793 ) 3794 params[key] = val 3795 del params['kwargs'] 3796 # verify the required parameter 'account_id' is set 3797 if ('account_id' not in params) or (params['account_id'] is None): 3798 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 3799 # verify the required parameter 'lang_code' is set 3800 if ('lang_code' not in params) or (params['lang_code'] is None): 3801 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 3802 3803 3804 collection_formats = {} 3805 3806 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 3807 path_params = {} 3808 if 'account_id' in params: 3809 path_params['accountId'] = params['account_id'] 3810 if 'lang_code' in params: 3811 path_params['langCode'] = params['lang_code'] 3812 3813 query_params = {} 3814 3815 header_params = {} 3816 3817 form_params = [] 3818 local_var_files = {} 3819 3820 body_params = None 3821 # HTTP header `Accept` 3822 header_params['Accept'] = self.api_client.\ 3823 select_header_accept(['application/json']) 3824 3825 # Authentication setting 3826 auth_settings = [] 3827 3828 return self.api_client.call_api(resource_path, 'GET', 3829 path_params, 3830 query_params, 3831 header_params, 3832 body=body_params, 3833 post_params=form_params, 3834 files=local_var_files, 3835 response_type='ConsumerDisclosure', 3836 auth_settings=auth_settings, 3837 callback=params.get('callback'), 3838 _return_http_data_only=params.get('_return_http_data_only'), 3839 _preload_content=params.get('_preload_content', True), 3840 _request_timeout=params.get('_request_timeout'), 3841 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), 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)
3843 def get_consumer_disclosure_default(self, account_id, **kwargs): 3844 """ 3845 Gets the Electronic Record and Signature Disclosure for the account. 3846 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. 3847 This method makes a synchronous HTTP request by default. To make an 3848 asynchronous HTTP request, please define a `callback` function 3849 to be invoked when receiving the response. 3850 >>> def callback_function(response): 3851 >>> pprint(response) 3852 >>> 3853 >>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function) 3854 3855 :param callback function: The callback function 3856 for asynchronous request. (optional) 3857 :param str account_id: The external account number (int) or account ID Guid. (required) 3858 :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. 3859 :return: ConsumerDisclosure 3860 If the method is called asynchronously, 3861 returns the request thread. 3862 """ 3863 kwargs['_return_http_data_only'] = True 3864 if kwargs.get('callback'): 3865 return self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3866 else: 3867 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3868 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)
3870 def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs): 3871 """ 3872 Gets the Electronic Record and Signature Disclosure for the account. 3873 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. 3874 This method makes a synchronous HTTP request by default. To make an 3875 asynchronous HTTP request, please define a `callback` function 3876 to be invoked when receiving the response. 3877 >>> def callback_function(response): 3878 >>> pprint(response) 3879 >>> 3880 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function) 3881 3882 :param callback function: The callback function 3883 for asynchronous request. (optional) 3884 :param str account_id: The external account number (int) or account ID Guid. (required) 3885 :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. 3886 :return: ConsumerDisclosure 3887 If the method is called asynchronously, 3888 returns the request thread. 3889 """ 3890 3891 all_params = ['account_id', 'lang_code'] 3892 all_params.append('callback') 3893 all_params.append('_return_http_data_only') 3894 all_params.append('_preload_content') 3895 all_params.append('_request_timeout') 3896 3897 params = locals() 3898 for key, val in iteritems(params['kwargs']): 3899 if key not in all_params: 3900 raise TypeError( 3901 "Got an unexpected keyword argument '%s'" 3902 " to method get_consumer_disclosure_default" % key 3903 ) 3904 params[key] = val 3905 del params['kwargs'] 3906 # verify the required parameter 'account_id' is set 3907 if ('account_id' not in params) or (params['account_id'] is None): 3908 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 3909 3910 3911 collection_formats = {} 3912 3913 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json') 3914 path_params = {} 3915 if 'account_id' in params: 3916 path_params['accountId'] = params['account_id'] 3917 3918 query_params = {} 3919 if 'lang_code' in params: 3920 query_params['langCode'] = params['lang_code'] 3921 3922 header_params = {} 3923 3924 form_params = [] 3925 local_var_files = {} 3926 3927 body_params = None 3928 # HTTP header `Accept` 3929 header_params['Accept'] = self.api_client.\ 3930 select_header_accept(['application/json']) 3931 3932 # Authentication setting 3933 auth_settings = [] 3934 3935 return self.api_client.call_api(resource_path, 'GET', 3936 path_params, 3937 query_params, 3938 header_params, 3939 body=body_params, 3940 post_params=form_params, 3941 files=local_var_files, 3942 response_type='ConsumerDisclosure', 3943 auth_settings=auth_settings, 3944 callback=params.get('callback'), 3945 _return_http_data_only=params.get('_return_http_data_only'), 3946 _preload_content=params.get('_preload_content', True), 3947 _request_timeout=params.get('_request_timeout'), 3948 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)
3950 def get_e_note_configuration(self, account_id, **kwargs): 3951 """ 3952 Returns the configuration information for the eNote eOriginal integration. 3953 3954 This method makes a synchronous HTTP request by default. To make an 3955 asynchronous HTTP request, please define a `callback` function 3956 to be invoked when receiving the response. 3957 >>> def callback_function(response): 3958 >>> pprint(response) 3959 >>> 3960 >>> thread = api.get_e_note_configuration(account_id, callback=callback_function) 3961 3962 :param callback function: The callback function 3963 for asynchronous request. (optional) 3964 :param str account_id: The external account number (int) or account ID Guid. (required) 3965 :return: ENoteConfiguration 3966 If the method is called asynchronously, 3967 returns the request thread. 3968 """ 3969 kwargs['_return_http_data_only'] = True 3970 if kwargs.get('callback'): 3971 return self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3972 else: 3973 (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3974 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)
3976 def get_e_note_configuration_with_http_info(self, account_id, **kwargs): 3977 """ 3978 Returns the configuration information for the eNote eOriginal integration. 3979 3980 This method makes a synchronous HTTP request by default. To make an 3981 asynchronous HTTP request, please define a `callback` function 3982 to be invoked when receiving the response. 3983 >>> def callback_function(response): 3984 >>> pprint(response) 3985 >>> 3986 >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function) 3987 3988 :param callback function: The callback function 3989 for asynchronous request. (optional) 3990 :param str account_id: The external account number (int) or account ID Guid. (required) 3991 :return: ENoteConfiguration 3992 If the method is called asynchronously, 3993 returns the request thread. 3994 """ 3995 3996 all_params = ['account_id'] 3997 all_params.append('callback') 3998 all_params.append('_return_http_data_only') 3999 all_params.append('_preload_content') 4000 all_params.append('_request_timeout') 4001 4002 params = locals() 4003 for key, val in iteritems(params['kwargs']): 4004 if key not in all_params: 4005 raise TypeError( 4006 "Got an unexpected keyword argument '%s'" 4007 " to method get_e_note_configuration" % key 4008 ) 4009 params[key] = val 4010 del params['kwargs'] 4011 # verify the required parameter 'account_id' is set 4012 if ('account_id' not in params) or (params['account_id'] is None): 4013 raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`") 4014 4015 4016 collection_formats = {} 4017 4018 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 4019 path_params = {} 4020 if 'account_id' in params: 4021 path_params['accountId'] = params['account_id'] 4022 4023 query_params = {} 4024 4025 header_params = {} 4026 4027 form_params = [] 4028 local_var_files = {} 4029 4030 body_params = None 4031 # HTTP header `Accept` 4032 header_params['Accept'] = self.api_client.\ 4033 select_header_accept(['application/json']) 4034 4035 # Authentication setting 4036 auth_settings = [] 4037 4038 return self.api_client.call_api(resource_path, 'GET', 4039 path_params, 4040 query_params, 4041 header_params, 4042 body=body_params, 4043 post_params=form_params, 4044 files=local_var_files, 4045 response_type='ENoteConfiguration', 4046 auth_settings=auth_settings, 4047 callback=params.get('callback'), 4048 _return_http_data_only=params.get('_return_http_data_only'), 4049 _preload_content=params.get('_preload_content', True), 4050 _request_timeout=params.get('_request_timeout'), 4051 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)
4053 def get_envelope_purge_configuration(self, account_id, **kwargs): 4054 """ 4055 Select envelope purge configuration. 4056 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. 4057 This method makes a synchronous HTTP request by default. To make an 4058 asynchronous HTTP request, please define a `callback` function 4059 to be invoked when receiving the response. 4060 >>> def callback_function(response): 4061 >>> pprint(response) 4062 >>> 4063 >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function) 4064 4065 :param callback function: The callback function 4066 for asynchronous request. (optional) 4067 :param str account_id: The external account number (int) or account ID Guid. (required) 4068 :return: EnvelopePurgeConfiguration 4069 If the method is called asynchronously, 4070 returns the request thread. 4071 """ 4072 kwargs['_return_http_data_only'] = True 4073 if kwargs.get('callback'): 4074 return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4075 else: 4076 (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 4077 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)
4079 def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 4080 """ 4081 Select envelope purge configuration. 4082 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. 4083 This method makes a synchronous HTTP request by default. To make an 4084 asynchronous HTTP request, please define a `callback` function 4085 to be invoked when receiving the response. 4086 >>> def callback_function(response): 4087 >>> pprint(response) 4088 >>> 4089 >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 4090 4091 :param callback function: The callback function 4092 for asynchronous request. (optional) 4093 :param str account_id: The external account number (int) or account ID Guid. (required) 4094 :return: EnvelopePurgeConfiguration 4095 If the method is called asynchronously, 4096 returns the request thread. 4097 """ 4098 4099 all_params = ['account_id'] 4100 all_params.append('callback') 4101 all_params.append('_return_http_data_only') 4102 all_params.append('_preload_content') 4103 all_params.append('_request_timeout') 4104 4105 params = locals() 4106 for key, val in iteritems(params['kwargs']): 4107 if key not in all_params: 4108 raise TypeError( 4109 "Got an unexpected keyword argument '%s'" 4110 " to method get_envelope_purge_configuration" % key 4111 ) 4112 params[key] = val 4113 del params['kwargs'] 4114 # verify the required parameter 'account_id' is set 4115 if ('account_id' not in params) or (params['account_id'] is None): 4116 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`") 4117 4118 4119 collection_formats = {} 4120 4121 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 4122 path_params = {} 4123 if 'account_id' in params: 4124 path_params['accountId'] = params['account_id'] 4125 4126 query_params = {} 4127 4128 header_params = {} 4129 4130 form_params = [] 4131 local_var_files = {} 4132 4133 body_params = None 4134 # HTTP header `Accept` 4135 header_params['Accept'] = self.api_client.\ 4136 select_header_accept(['application/json']) 4137 4138 # Authentication setting 4139 auth_settings = [] 4140 4141 return self.api_client.call_api(resource_path, 'GET', 4142 path_params, 4143 query_params, 4144 header_params, 4145 body=body_params, 4146 post_params=form_params, 4147 files=local_var_files, 4148 response_type='EnvelopePurgeConfiguration', 4149 auth_settings=auth_settings, 4150 callback=params.get('callback'), 4151 _return_http_data_only=params.get('_return_http_data_only'), 4152 _preload_content=params.get('_preload_content', True), 4153 _request_timeout=params.get('_request_timeout'), 4154 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)
4156 def get_favorite_templates(self, account_id, **kwargs): 4157 """ 4158 Retrieves the list of favorited templates for this caller 4159 4160 This method makes a synchronous HTTP request by default. To make an 4161 asynchronous HTTP request, please define a `callback` function 4162 to be invoked when receiving the response. 4163 >>> def callback_function(response): 4164 >>> pprint(response) 4165 >>> 4166 >>> thread = api.get_favorite_templates(account_id, callback=callback_function) 4167 4168 :param callback function: The callback function 4169 for asynchronous request. (optional) 4170 :param str account_id: The external account number (int) or account ID Guid. (required) 4171 :return: FavoriteTemplatesInfo 4172 If the method is called asynchronously, 4173 returns the request thread. 4174 """ 4175 kwargs['_return_http_data_only'] = True 4176 if kwargs.get('callback'): 4177 return self.get_favorite_templates_with_http_info(account_id, **kwargs) 4178 else: 4179 (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs) 4180 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)
4182 def get_favorite_templates_with_http_info(self, account_id, **kwargs): 4183 """ 4184 Retrieves the list of favorited templates for this caller 4185 4186 This method makes a synchronous HTTP request by default. To make an 4187 asynchronous HTTP request, please define a `callback` function 4188 to be invoked when receiving the response. 4189 >>> def callback_function(response): 4190 >>> pprint(response) 4191 >>> 4192 >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function) 4193 4194 :param callback function: The callback function 4195 for asynchronous request. (optional) 4196 :param str account_id: The external account number (int) or account ID Guid. (required) 4197 :return: FavoriteTemplatesInfo 4198 If the method is called asynchronously, 4199 returns the request thread. 4200 """ 4201 4202 all_params = ['account_id'] 4203 all_params.append('callback') 4204 all_params.append('_return_http_data_only') 4205 all_params.append('_preload_content') 4206 all_params.append('_request_timeout') 4207 4208 params = locals() 4209 for key, val in iteritems(params['kwargs']): 4210 if key not in all_params: 4211 raise TypeError( 4212 "Got an unexpected keyword argument '%s'" 4213 " to method get_favorite_templates" % key 4214 ) 4215 params[key] = val 4216 del params['kwargs'] 4217 # verify the required parameter 'account_id' is set 4218 if ('account_id' not in params) or (params['account_id'] is None): 4219 raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`") 4220 4221 4222 collection_formats = {} 4223 4224 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 4225 path_params = {} 4226 if 'account_id' in params: 4227 path_params['accountId'] = params['account_id'] 4228 4229 query_params = {} 4230 4231 header_params = {} 4232 4233 form_params = [] 4234 local_var_files = {} 4235 4236 body_params = None 4237 # HTTP header `Accept` 4238 header_params['Accept'] = self.api_client.\ 4239 select_header_accept(['application/json']) 4240 4241 # Authentication setting 4242 auth_settings = [] 4243 4244 return self.api_client.call_api(resource_path, 'GET', 4245 path_params, 4246 query_params, 4247 header_params, 4248 body=body_params, 4249 post_params=form_params, 4250 files=local_var_files, 4251 response_type='FavoriteTemplatesInfo', 4252 auth_settings=auth_settings, 4253 callback=params.get('callback'), 4254 _return_http_data_only=params.get('_return_http_data_only'), 4255 _preload_content=params.get('_preload_content', True), 4256 _request_timeout=params.get('_request_timeout'), 4257 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)
4259 def get_notification_defaults(self, account_id, **kwargs): 4260 """ 4261 Returns default user level settings for a specified account 4262 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4263 This method makes a synchronous HTTP request by default. To make an 4264 asynchronous HTTP request, please define a `callback` function 4265 to be invoked when receiving the response. 4266 >>> def callback_function(response): 4267 >>> pprint(response) 4268 >>> 4269 >>> thread = api.get_notification_defaults(account_id, callback=callback_function) 4270 4271 :param callback function: The callback function 4272 for asynchronous request. (optional) 4273 :param str account_id: The external account number (int) or account ID Guid. (required) 4274 :return: NotificationDefaults 4275 If the method is called asynchronously, 4276 returns the request thread. 4277 """ 4278 kwargs['_return_http_data_only'] = True 4279 if kwargs.get('callback'): 4280 return self.get_notification_defaults_with_http_info(account_id, **kwargs) 4281 else: 4282 (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs) 4283 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)
4285 def get_notification_defaults_with_http_info(self, account_id, **kwargs): 4286 """ 4287 Returns default user level settings for a specified account 4288 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 4289 This method makes a synchronous HTTP request by default. To make an 4290 asynchronous HTTP request, please define a `callback` function 4291 to be invoked when receiving the response. 4292 >>> def callback_function(response): 4293 >>> pprint(response) 4294 >>> 4295 >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function) 4296 4297 :param callback function: The callback function 4298 for asynchronous request. (optional) 4299 :param str account_id: The external account number (int) or account ID Guid. (required) 4300 :return: NotificationDefaults 4301 If the method is called asynchronously, 4302 returns the request thread. 4303 """ 4304 4305 all_params = ['account_id'] 4306 all_params.append('callback') 4307 all_params.append('_return_http_data_only') 4308 all_params.append('_preload_content') 4309 all_params.append('_request_timeout') 4310 4311 params = locals() 4312 for key, val in iteritems(params['kwargs']): 4313 if key not in all_params: 4314 raise TypeError( 4315 "Got an unexpected keyword argument '%s'" 4316 " to method get_notification_defaults" % key 4317 ) 4318 params[key] = val 4319 del params['kwargs'] 4320 # verify the required parameter 'account_id' is set 4321 if ('account_id' not in params) or (params['account_id'] is None): 4322 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`") 4323 4324 4325 collection_formats = {} 4326 4327 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 4328 path_params = {} 4329 if 'account_id' in params: 4330 path_params['accountId'] = params['account_id'] 4331 4332 query_params = {} 4333 4334 header_params = {} 4335 4336 form_params = [] 4337 local_var_files = {} 4338 4339 body_params = None 4340 # HTTP header `Accept` 4341 header_params['Accept'] = self.api_client.\ 4342 select_header_accept(['application/json']) 4343 4344 # Authentication setting 4345 auth_settings = [] 4346 4347 return self.api_client.call_api(resource_path, 'GET', 4348 path_params, 4349 query_params, 4350 header_params, 4351 body=body_params, 4352 post_params=form_params, 4353 files=local_var_files, 4354 response_type='NotificationDefaults', 4355 auth_settings=auth_settings, 4356 callback=params.get('callback'), 4357 _return_http_data_only=params.get('_return_http_data_only'), 4358 _preload_content=params.get('_preload_content', True), 4359 _request_timeout=params.get('_request_timeout'), 4360 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)
4362 def get_password_rules(self, account_id, **kwargs): 4363 """ 4364 Get the password rules 4365 This method retrieves the password rules for an account. 4366 This method makes a synchronous HTTP request by default. To make an 4367 asynchronous HTTP request, please define a `callback` function 4368 to be invoked when receiving the response. 4369 >>> def callback_function(response): 4370 >>> pprint(response) 4371 >>> 4372 >>> thread = api.get_password_rules(account_id, callback=callback_function) 4373 4374 :param callback function: The callback function 4375 for asynchronous request. (optional) 4376 :param str account_id: The external account number (int) or account ID Guid. (required) 4377 :return: AccountPasswordRules 4378 If the method is called asynchronously, 4379 returns the request thread. 4380 """ 4381 kwargs['_return_http_data_only'] = True 4382 if kwargs.get('callback'): 4383 return self.get_password_rules_with_http_info(account_id, **kwargs) 4384 else: 4385 (data) = self.get_password_rules_with_http_info(account_id, **kwargs) 4386 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)
4388 def get_password_rules_with_http_info(self, account_id, **kwargs): 4389 """ 4390 Get the password rules 4391 This method retrieves the password rules for an account. 4392 This method makes a synchronous HTTP request by default. To make an 4393 asynchronous HTTP request, please define a `callback` function 4394 to be invoked when receiving the response. 4395 >>> def callback_function(response): 4396 >>> pprint(response) 4397 >>> 4398 >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function) 4399 4400 :param callback function: The callback function 4401 for asynchronous request. (optional) 4402 :param str account_id: The external account number (int) or account ID Guid. (required) 4403 :return: AccountPasswordRules 4404 If the method is called asynchronously, 4405 returns the request thread. 4406 """ 4407 4408 all_params = ['account_id'] 4409 all_params.append('callback') 4410 all_params.append('_return_http_data_only') 4411 all_params.append('_preload_content') 4412 all_params.append('_request_timeout') 4413 4414 params = locals() 4415 for key, val in iteritems(params['kwargs']): 4416 if key not in all_params: 4417 raise TypeError( 4418 "Got an unexpected keyword argument '%s'" 4419 " to method get_password_rules" % key 4420 ) 4421 params[key] = val 4422 del params['kwargs'] 4423 # verify the required parameter 'account_id' is set 4424 if ('account_id' not in params) or (params['account_id'] is None): 4425 raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`") 4426 4427 4428 collection_formats = {} 4429 4430 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 4431 path_params = {} 4432 if 'account_id' in params: 4433 path_params['accountId'] = params['account_id'] 4434 4435 query_params = {} 4436 4437 header_params = {} 4438 4439 form_params = [] 4440 local_var_files = {} 4441 4442 body_params = None 4443 # HTTP header `Accept` 4444 header_params['Accept'] = self.api_client.\ 4445 select_header_accept(['application/json']) 4446 4447 # Authentication setting 4448 auth_settings = [] 4449 4450 return self.api_client.call_api(resource_path, 'GET', 4451 path_params, 4452 query_params, 4453 header_params, 4454 body=body_params, 4455 post_params=form_params, 4456 files=local_var_files, 4457 response_type='AccountPasswordRules', 4458 auth_settings=auth_settings, 4459 callback=params.get('callback'), 4460 _return_http_data_only=params.get('_return_http_data_only'), 4461 _preload_content=params.get('_preload_content', True), 4462 _request_timeout=params.get('_request_timeout'), 4463 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)
4465 def get_password_rules_0(self, **kwargs): 4466 """ 4467 Get membership account password rules 4468 4469 This method makes a synchronous HTTP request by default. To make an 4470 asynchronous HTTP request, please define a `callback` function 4471 to be invoked when receiving the response. 4472 >>> def callback_function(response): 4473 >>> pprint(response) 4474 >>> 4475 >>> thread = api.get_password_rules_0(callback=callback_function) 4476 4477 :param callback function: The callback function 4478 for asynchronous request. (optional) 4479 :return: UserPasswordRules 4480 If the method is called asynchronously, 4481 returns the request thread. 4482 """ 4483 kwargs['_return_http_data_only'] = True 4484 if kwargs.get('callback'): 4485 return self.get_password_rules_0_with_http_info(**kwargs) 4486 else: 4487 (data) = self.get_password_rules_0_with_http_info(**kwargs) 4488 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)
4490 def get_password_rules_0_with_http_info(self, **kwargs): 4491 """ 4492 Get membership account password rules 4493 4494 This method makes a synchronous HTTP request by default. To make an 4495 asynchronous HTTP request, please define a `callback` function 4496 to be invoked when receiving the response. 4497 >>> def callback_function(response): 4498 >>> pprint(response) 4499 >>> 4500 >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function) 4501 4502 :param callback function: The callback function 4503 for asynchronous request. (optional) 4504 :return: UserPasswordRules 4505 If the method is called asynchronously, 4506 returns the request thread. 4507 """ 4508 4509 all_params = [] 4510 all_params.append('callback') 4511 all_params.append('_return_http_data_only') 4512 all_params.append('_preload_content') 4513 all_params.append('_request_timeout') 4514 4515 params = locals() 4516 for key, val in iteritems(params['kwargs']): 4517 if key not in all_params: 4518 raise TypeError( 4519 "Got an unexpected keyword argument '%s'" 4520 " to method get_password_rules_0" % key 4521 ) 4522 params[key] = val 4523 del params['kwargs'] 4524 4525 collection_formats = {} 4526 4527 resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json') 4528 path_params = {} 4529 4530 query_params = {} 4531 4532 header_params = {} 4533 4534 form_params = [] 4535 local_var_files = {} 4536 4537 body_params = None 4538 # HTTP header `Accept` 4539 header_params['Accept'] = self.api_client.\ 4540 select_header_accept(['application/json']) 4541 4542 # Authentication setting 4543 auth_settings = [] 4544 4545 return self.api_client.call_api(resource_path, 'GET', 4546 path_params, 4547 query_params, 4548 header_params, 4549 body=body_params, 4550 post_params=form_params, 4551 files=local_var_files, 4552 response_type='UserPasswordRules', 4553 auth_settings=auth_settings, 4554 callback=params.get('callback'), 4555 _return_http_data_only=params.get('_return_http_data_only'), 4556 _preload_content=params.get('_preload_content', True), 4557 _request_timeout=params.get('_request_timeout'), 4558 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)
4560 def get_permission_profile(self, account_id, permission_profile_id, **kwargs): 4561 """ 4562 Returns a permissions profile in the specified account. 4563 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/) 4564 This method makes a synchronous HTTP request by default. To make an 4565 asynchronous HTTP request, please define a `callback` function 4566 to be invoked when receiving the response. 4567 >>> def callback_function(response): 4568 >>> pprint(response) 4569 >>> 4570 >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function) 4571 4572 :param callback function: The callback function 4573 for asynchronous request. (optional) 4574 :param str account_id: The external account number (int) or account ID Guid. (required) 4575 :param str permission_profile_id: (required) 4576 :param str include: 4577 :return: PermissionProfile 4578 If the method is called asynchronously, 4579 returns the request thread. 4580 """ 4581 kwargs['_return_http_data_only'] = True 4582 if kwargs.get('callback'): 4583 return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4584 else: 4585 (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 4586 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)
4588 def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 4589 """ 4590 Returns a permissions profile in the specified account. 4591 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/) 4592 This method makes a synchronous HTTP request by default. To make an 4593 asynchronous HTTP request, please define a `callback` function 4594 to be invoked when receiving the response. 4595 >>> def callback_function(response): 4596 >>> pprint(response) 4597 >>> 4598 >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 4599 4600 :param callback function: The callback function 4601 for asynchronous request. (optional) 4602 :param str account_id: The external account number (int) or account ID Guid. (required) 4603 :param str permission_profile_id: (required) 4604 :param str include: 4605 :return: PermissionProfile 4606 If the method is called asynchronously, 4607 returns the request thread. 4608 """ 4609 4610 all_params = ['account_id', 'permission_profile_id', 'include'] 4611 all_params.append('callback') 4612 all_params.append('_return_http_data_only') 4613 all_params.append('_preload_content') 4614 all_params.append('_request_timeout') 4615 4616 params = locals() 4617 for key, val in iteritems(params['kwargs']): 4618 if key not in all_params: 4619 raise TypeError( 4620 "Got an unexpected keyword argument '%s'" 4621 " to method get_permission_profile" % key 4622 ) 4623 params[key] = val 4624 del params['kwargs'] 4625 # verify the required parameter 'account_id' is set 4626 if ('account_id' not in params) or (params['account_id'] is None): 4627 raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`") 4628 # verify the required parameter 'permission_profile_id' is set 4629 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 4630 raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`") 4631 4632 4633 collection_formats = {} 4634 4635 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 4636 path_params = {} 4637 if 'account_id' in params: 4638 path_params['accountId'] = params['account_id'] 4639 if 'permission_profile_id' in params: 4640 path_params['permissionProfileId'] = params['permission_profile_id'] 4641 4642 query_params = {} 4643 if 'include' in params: 4644 query_params['include'] = params['include'] 4645 4646 header_params = {} 4647 4648 form_params = [] 4649 local_var_files = {} 4650 4651 body_params = None 4652 # HTTP header `Accept` 4653 header_params['Accept'] = self.api_client.\ 4654 select_header_accept(['application/json']) 4655 4656 # Authentication setting 4657 auth_settings = [] 4658 4659 return self.api_client.call_api(resource_path, 'GET', 4660 path_params, 4661 query_params, 4662 header_params, 4663 body=body_params, 4664 post_params=form_params, 4665 files=local_var_files, 4666 response_type='PermissionProfile', 4667 auth_settings=auth_settings, 4668 callback=params.get('callback'), 4669 _return_http_data_only=params.get('_return_http_data_only'), 4670 _preload_content=params.get('_preload_content', True), 4671 _request_timeout=params.get('_request_timeout'), 4672 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)
4810 def get_provisioning(self, **kwargs): 4811 """ 4812 Retrieves the account provisioning information for the account. 4813 Retrieves the account provisioning information for the account. 4814 This method makes a synchronous HTTP request by default. To make an 4815 asynchronous HTTP request, please define a `callback` function 4816 to be invoked when receiving the response. 4817 >>> def callback_function(response): 4818 >>> pprint(response) 4819 >>> 4820 >>> thread = api.get_provisioning(callback=callback_function) 4821 4822 :param callback function: The callback function 4823 for asynchronous request. (optional) 4824 :return: ProvisioningInformation 4825 If the method is called asynchronously, 4826 returns the request thread. 4827 """ 4828 kwargs['_return_http_data_only'] = True 4829 if kwargs.get('callback'): 4830 return self.get_provisioning_with_http_info(**kwargs) 4831 else: 4832 (data) = self.get_provisioning_with_http_info(**kwargs) 4833 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)
4835 def get_provisioning_with_http_info(self, **kwargs): 4836 """ 4837 Retrieves the account provisioning information for the account. 4838 Retrieves the account provisioning information for the account. 4839 This method makes a synchronous HTTP request by default. To make an 4840 asynchronous HTTP request, please define a `callback` function 4841 to be invoked when receiving the response. 4842 >>> def callback_function(response): 4843 >>> pprint(response) 4844 >>> 4845 >>> thread = api.get_provisioning_with_http_info(callback=callback_function) 4846 4847 :param callback function: The callback function 4848 for asynchronous request. (optional) 4849 :return: ProvisioningInformation 4850 If the method is called asynchronously, 4851 returns the request thread. 4852 """ 4853 4854 all_params = [] 4855 all_params.append('callback') 4856 all_params.append('_return_http_data_only') 4857 all_params.append('_preload_content') 4858 all_params.append('_request_timeout') 4859 4860 params = locals() 4861 for key, val in iteritems(params['kwargs']): 4862 if key not in all_params: 4863 raise TypeError( 4864 "Got an unexpected keyword argument '%s'" 4865 " to method get_provisioning" % key 4866 ) 4867 params[key] = val 4868 del params['kwargs'] 4869 4870 collection_formats = {} 4871 4872 resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json') 4873 path_params = {} 4874 4875 query_params = {} 4876 4877 header_params = {} 4878 4879 form_params = [] 4880 local_var_files = {} 4881 4882 body_params = None 4883 # HTTP header `Accept` 4884 header_params['Accept'] = self.api_client.\ 4885 select_header_accept(['application/json']) 4886 4887 # Authentication setting 4888 auth_settings = [] 4889 4890 return self.api_client.call_api(resource_path, 'GET', 4891 path_params, 4892 query_params, 4893 header_params, 4894 body=body_params, 4895 post_params=form_params, 4896 files=local_var_files, 4897 response_type='ProvisioningInformation', 4898 auth_settings=auth_settings, 4899 callback=params.get('callback'), 4900 _return_http_data_only=params.get('_return_http_data_only'), 4901 _preload_content=params.get('_preload_content', True), 4902 _request_timeout=params.get('_request_timeout'), 4903 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)
4905 def get_supported_languages(self, account_id, **kwargs): 4906 """ 4907 Gets list of supported languages for recipient language setting. 4908 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). 4909 This method makes a synchronous HTTP request by default. To make an 4910 asynchronous HTTP request, please define a `callback` function 4911 to be invoked when receiving the response. 4912 >>> def callback_function(response): 4913 >>> pprint(response) 4914 >>> 4915 >>> thread = api.get_supported_languages(account_id, callback=callback_function) 4916 4917 :param callback function: The callback function 4918 for asynchronous request. (optional) 4919 :param str account_id: The external account number (int) or account ID Guid. (required) 4920 :return: SupportedLanguages 4921 If the method is called asynchronously, 4922 returns the request thread. 4923 """ 4924 kwargs['_return_http_data_only'] = True 4925 if kwargs.get('callback'): 4926 return self.get_supported_languages_with_http_info(account_id, **kwargs) 4927 else: 4928 (data) = self.get_supported_languages_with_http_info(account_id, **kwargs) 4929 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)
4931 def get_supported_languages_with_http_info(self, account_id, **kwargs): 4932 """ 4933 Gets list of supported languages for recipient language setting. 4934 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). 4935 This method makes a synchronous HTTP request by default. To make an 4936 asynchronous HTTP request, please define a `callback` function 4937 to be invoked when receiving the response. 4938 >>> def callback_function(response): 4939 >>> pprint(response) 4940 >>> 4941 >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function) 4942 4943 :param callback function: The callback function 4944 for asynchronous request. (optional) 4945 :param str account_id: The external account number (int) or account ID Guid. (required) 4946 :return: SupportedLanguages 4947 If the method is called asynchronously, 4948 returns the request thread. 4949 """ 4950 4951 all_params = ['account_id'] 4952 all_params.append('callback') 4953 all_params.append('_return_http_data_only') 4954 all_params.append('_preload_content') 4955 all_params.append('_request_timeout') 4956 4957 params = locals() 4958 for key, val in iteritems(params['kwargs']): 4959 if key not in all_params: 4960 raise TypeError( 4961 "Got an unexpected keyword argument '%s'" 4962 " to method get_supported_languages" % key 4963 ) 4964 params[key] = val 4965 del params['kwargs'] 4966 # verify the required parameter 'account_id' is set 4967 if ('account_id' not in params) or (params['account_id'] is None): 4968 raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`") 4969 4970 4971 collection_formats = {} 4972 4973 resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json') 4974 path_params = {} 4975 if 'account_id' in params: 4976 path_params['accountId'] = params['account_id'] 4977 4978 query_params = {} 4979 4980 header_params = {} 4981 4982 form_params = [] 4983 local_var_files = {} 4984 4985 body_params = None 4986 # HTTP header `Accept` 4987 header_params['Accept'] = self.api_client.\ 4988 select_header_accept(['application/json']) 4989 4990 # Authentication setting 4991 auth_settings = [] 4992 4993 return self.api_client.call_api(resource_path, 'GET', 4994 path_params, 4995 query_params, 4996 header_params, 4997 body=body_params, 4998 post_params=form_params, 4999 files=local_var_files, 5000 response_type='SupportedLanguages', 5001 auth_settings=auth_settings, 5002 callback=params.get('callback'), 5003 _return_http_data_only=params.get('_return_http_data_only'), 5004 _preload_content=params.get('_preload_content', True), 5005 _request_timeout=params.get('_request_timeout'), 5006 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)
5123 def get_watermark(self, account_id, **kwargs): 5124 """ 5125 Get watermark information. 5126 5127 This method makes a synchronous HTTP request by default. To make an 5128 asynchronous HTTP request, please define a `callback` function 5129 to be invoked when receiving the response. 5130 >>> def callback_function(response): 5131 >>> pprint(response) 5132 >>> 5133 >>> thread = api.get_watermark(account_id, callback=callback_function) 5134 5135 :param callback function: The callback function 5136 for asynchronous request. (optional) 5137 :param str account_id: The external account number (int) or account ID Guid. (required) 5138 :return: Watermark 5139 If the method is called asynchronously, 5140 returns the request thread. 5141 """ 5142 kwargs['_return_http_data_only'] = True 5143 if kwargs.get('callback'): 5144 return self.get_watermark_with_http_info(account_id, **kwargs) 5145 else: 5146 (data) = self.get_watermark_with_http_info(account_id, **kwargs) 5147 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)
5149 def get_watermark_with_http_info(self, account_id, **kwargs): 5150 """ 5151 Get watermark information. 5152 5153 This method makes a synchronous HTTP request by default. To make an 5154 asynchronous HTTP request, please define a `callback` function 5155 to be invoked when receiving the response. 5156 >>> def callback_function(response): 5157 >>> pprint(response) 5158 >>> 5159 >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function) 5160 5161 :param callback function: The callback function 5162 for asynchronous request. (optional) 5163 :param str account_id: The external account number (int) or account ID Guid. (required) 5164 :return: Watermark 5165 If the method is called asynchronously, 5166 returns the request thread. 5167 """ 5168 5169 all_params = ['account_id'] 5170 all_params.append('callback') 5171 all_params.append('_return_http_data_only') 5172 all_params.append('_preload_content') 5173 all_params.append('_request_timeout') 5174 5175 params = locals() 5176 for key, val in iteritems(params['kwargs']): 5177 if key not in all_params: 5178 raise TypeError( 5179 "Got an unexpected keyword argument '%s'" 5180 " to method get_watermark" % key 5181 ) 5182 params[key] = val 5183 del params['kwargs'] 5184 # verify the required parameter 'account_id' is set 5185 if ('account_id' not in params) or (params['account_id'] is None): 5186 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`") 5187 5188 5189 collection_formats = {} 5190 5191 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 5192 path_params = {} 5193 if 'account_id' in params: 5194 path_params['accountId'] = params['account_id'] 5195 5196 query_params = {} 5197 5198 header_params = {} 5199 5200 form_params = [] 5201 local_var_files = {} 5202 5203 body_params = None 5204 # HTTP header `Accept` 5205 header_params['Accept'] = self.api_client.\ 5206 select_header_accept(['application/json']) 5207 5208 # Authentication setting 5209 auth_settings = [] 5210 5211 return self.api_client.call_api(resource_path, 'GET', 5212 path_params, 5213 query_params, 5214 header_params, 5215 body=body_params, 5216 post_params=form_params, 5217 files=local_var_files, 5218 response_type='Watermark', 5219 auth_settings=auth_settings, 5220 callback=params.get('callback'), 5221 _return_http_data_only=params.get('_return_http_data_only'), 5222 _preload_content=params.get('_preload_content', True), 5223 _request_timeout=params.get('_request_timeout'), 5224 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)
5226 def get_watermark_preview(self, account_id, **kwargs): 5227 """ 5228 Get watermark preview. 5229 5230 This method makes a synchronous HTTP request by default. To make an 5231 asynchronous HTTP request, please define a `callback` function 5232 to be invoked when receiving the response. 5233 >>> def callback_function(response): 5234 >>> pprint(response) 5235 >>> 5236 >>> thread = api.get_watermark_preview(account_id, callback=callback_function) 5237 5238 :param callback function: The callback function 5239 for asynchronous request. (optional) 5240 :param str account_id: The external account number (int) or account ID Guid. (required) 5241 :param Watermark watermark: 5242 :return: Watermark 5243 If the method is called asynchronously, 5244 returns the request thread. 5245 """ 5246 kwargs['_return_http_data_only'] = True 5247 if kwargs.get('callback'): 5248 return self.get_watermark_preview_with_http_info(account_id, **kwargs) 5249 else: 5250 (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs) 5251 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)
5253 def get_watermark_preview_with_http_info(self, account_id, **kwargs): 5254 """ 5255 Get watermark preview. 5256 5257 This method makes a synchronous HTTP request by default. To make an 5258 asynchronous HTTP request, please define a `callback` function 5259 to be invoked when receiving the response. 5260 >>> def callback_function(response): 5261 >>> pprint(response) 5262 >>> 5263 >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function) 5264 5265 :param callback function: The callback function 5266 for asynchronous request. (optional) 5267 :param str account_id: The external account number (int) or account ID Guid. (required) 5268 :param Watermark watermark: 5269 :return: Watermark 5270 If the method is called asynchronously, 5271 returns the request thread. 5272 """ 5273 5274 all_params = ['account_id', 'watermark'] 5275 all_params.append('callback') 5276 all_params.append('_return_http_data_only') 5277 all_params.append('_preload_content') 5278 all_params.append('_request_timeout') 5279 5280 params = locals() 5281 for key, val in iteritems(params['kwargs']): 5282 if key not in all_params: 5283 raise TypeError( 5284 "Got an unexpected keyword argument '%s'" 5285 " to method get_watermark_preview" % key 5286 ) 5287 params[key] = val 5288 del params['kwargs'] 5289 # verify the required parameter 'account_id' is set 5290 if ('account_id' not in params) or (params['account_id'] is None): 5291 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`") 5292 5293 5294 collection_formats = {} 5295 5296 resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json') 5297 path_params = {} 5298 if 'account_id' in params: 5299 path_params['accountId'] = params['account_id'] 5300 5301 query_params = {} 5302 5303 header_params = {} 5304 5305 form_params = [] 5306 local_var_files = {} 5307 5308 body_params = None 5309 if 'watermark' in params: 5310 body_params = params['watermark'] 5311 # HTTP header `Accept` 5312 header_params['Accept'] = self.api_client.\ 5313 select_header_accept(['application/json']) 5314 5315 # Authentication setting 5316 auth_settings = [] 5317 5318 return self.api_client.call_api(resource_path, 'PUT', 5319 path_params, 5320 query_params, 5321 header_params, 5322 body=body_params, 5323 post_params=form_params, 5324 files=local_var_files, 5325 response_type='Watermark', 5326 auth_settings=auth_settings, 5327 callback=params.get('callback'), 5328 _return_http_data_only=params.get('_return_http_data_only'), 5329 _preload_content=params.get('_preload_content', True), 5330 _request_timeout=params.get('_request_timeout'), 5331 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)
5333 def list_brands(self, account_id, **kwargs): 5334 """ 5335 Gets a list of brand profiles. 5336 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. 5337 This method makes a synchronous HTTP request by default. To make an 5338 asynchronous HTTP request, please define a `callback` function 5339 to be invoked when receiving the response. 5340 >>> def callback_function(response): 5341 >>> pprint(response) 5342 >>> 5343 >>> thread = api.list_brands(account_id, callback=callback_function) 5344 5345 :param callback function: The callback function 5346 for asynchronous request. (optional) 5347 :param str account_id: The external account number (int) or account ID Guid. (required) 5348 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5349 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5350 :return: BrandsResponse 5351 If the method is called asynchronously, 5352 returns the request thread. 5353 """ 5354 kwargs['_return_http_data_only'] = True 5355 if kwargs.get('callback'): 5356 return self.list_brands_with_http_info(account_id, **kwargs) 5357 else: 5358 (data) = self.list_brands_with_http_info(account_id, **kwargs) 5359 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)
5361 def list_brands_with_http_info(self, account_id, **kwargs): 5362 """ 5363 Gets a list of brand profiles. 5364 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. 5365 This method makes a synchronous HTTP request by default. To make an 5366 asynchronous HTTP request, please define a `callback` function 5367 to be invoked when receiving the response. 5368 >>> def callback_function(response): 5369 >>> pprint(response) 5370 >>> 5371 >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function) 5372 5373 :param callback function: The callback function 5374 for asynchronous request. (optional) 5375 :param str account_id: The external account number (int) or account ID Guid. (required) 5376 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 5377 :param str include_logos: When set to **true**, returns the logos associated with the brand. 5378 :return: BrandsResponse 5379 If the method is called asynchronously, 5380 returns the request thread. 5381 """ 5382 5383 all_params = ['account_id', 'exclude_distributor_brand', 'include_logos'] 5384 all_params.append('callback') 5385 all_params.append('_return_http_data_only') 5386 all_params.append('_preload_content') 5387 all_params.append('_request_timeout') 5388 5389 params = locals() 5390 for key, val in iteritems(params['kwargs']): 5391 if key not in all_params: 5392 raise TypeError( 5393 "Got an unexpected keyword argument '%s'" 5394 " to method list_brands" % key 5395 ) 5396 params[key] = val 5397 del params['kwargs'] 5398 # verify the required parameter 'account_id' is set 5399 if ('account_id' not in params) or (params['account_id'] is None): 5400 raise ValueError("Missing the required parameter `account_id` when calling `list_brands`") 5401 5402 5403 collection_formats = {} 5404 5405 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 5406 path_params = {} 5407 if 'account_id' in params: 5408 path_params['accountId'] = params['account_id'] 5409 5410 query_params = {} 5411 if 'exclude_distributor_brand' in params: 5412 query_params['exclude_distributor_brand'] = params['exclude_distributor_brand'] 5413 if 'include_logos' in params: 5414 query_params['include_logos'] = params['include_logos'] 5415 5416 header_params = {} 5417 5418 form_params = [] 5419 local_var_files = {} 5420 5421 body_params = None 5422 # HTTP header `Accept` 5423 header_params['Accept'] = self.api_client.\ 5424 select_header_accept(['application/json']) 5425 5426 # Authentication setting 5427 auth_settings = [] 5428 5429 return self.api_client.call_api(resource_path, 'GET', 5430 path_params, 5431 query_params, 5432 header_params, 5433 body=body_params, 5434 post_params=form_params, 5435 files=local_var_files, 5436 response_type='BrandsResponse', 5437 auth_settings=auth_settings, 5438 callback=params.get('callback'), 5439 _return_http_data_only=params.get('_return_http_data_only'), 5440 _preload_content=params.get('_preload_content', True), 5441 _request_timeout=params.get('_request_timeout'), 5442 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)
5444 def list_custom_fields(self, account_id, **kwargs): 5445 """ 5446 Gets a list of custom fields associated with the account. 5447 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. 5448 This method makes a synchronous HTTP request by default. To make an 5449 asynchronous HTTP request, please define a `callback` function 5450 to be invoked when receiving the response. 5451 >>> def callback_function(response): 5452 >>> pprint(response) 5453 >>> 5454 >>> thread = api.list_custom_fields(account_id, callback=callback_function) 5455 5456 :param callback function: The callback function 5457 for asynchronous request. (optional) 5458 :param str account_id: The external account number (int) or account ID Guid. (required) 5459 :return: CustomFields 5460 If the method is called asynchronously, 5461 returns the request thread. 5462 """ 5463 kwargs['_return_http_data_only'] = True 5464 if kwargs.get('callback'): 5465 return self.list_custom_fields_with_http_info(account_id, **kwargs) 5466 else: 5467 (data) = self.list_custom_fields_with_http_info(account_id, **kwargs) 5468 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)
5470 def list_custom_fields_with_http_info(self, account_id, **kwargs): 5471 """ 5472 Gets a list of custom fields associated with the account. 5473 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. 5474 This method makes a synchronous HTTP request by default. To make an 5475 asynchronous HTTP request, please define a `callback` function 5476 to be invoked when receiving the response. 5477 >>> def callback_function(response): 5478 >>> pprint(response) 5479 >>> 5480 >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function) 5481 5482 :param callback function: The callback function 5483 for asynchronous request. (optional) 5484 :param str account_id: The external account number (int) or account ID Guid. (required) 5485 :return: CustomFields 5486 If the method is called asynchronously, 5487 returns the request thread. 5488 """ 5489 5490 all_params = ['account_id'] 5491 all_params.append('callback') 5492 all_params.append('_return_http_data_only') 5493 all_params.append('_preload_content') 5494 all_params.append('_request_timeout') 5495 5496 params = locals() 5497 for key, val in iteritems(params['kwargs']): 5498 if key not in all_params: 5499 raise TypeError( 5500 "Got an unexpected keyword argument '%s'" 5501 " to method list_custom_fields" % key 5502 ) 5503 params[key] = val 5504 del params['kwargs'] 5505 # verify the required parameter 'account_id' is set 5506 if ('account_id' not in params) or (params['account_id'] is None): 5507 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 5508 5509 5510 collection_formats = {} 5511 5512 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 5513 path_params = {} 5514 if 'account_id' in params: 5515 path_params['accountId'] = params['account_id'] 5516 5517 query_params = {} 5518 5519 header_params = {} 5520 5521 form_params = [] 5522 local_var_files = {} 5523 5524 body_params = None 5525 # HTTP header `Accept` 5526 header_params['Accept'] = self.api_client.\ 5527 select_header_accept(['application/json']) 5528 5529 # Authentication setting 5530 auth_settings = [] 5531 5532 return self.api_client.call_api(resource_path, 'GET', 5533 path_params, 5534 query_params, 5535 header_params, 5536 body=body_params, 5537 post_params=form_params, 5538 files=local_var_files, 5539 response_type='CustomFields', 5540 auth_settings=auth_settings, 5541 callback=params.get('callback'), 5542 _return_http_data_only=params.get('_return_http_data_only'), 5543 _preload_content=params.get('_preload_content', True), 5544 _request_timeout=params.get('_request_timeout'), 5545 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)
5547 def list_permissions(self, account_id, **kwargs): 5548 """ 5549 Gets a list of permission profiles. 5550 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. 5551 This method makes a synchronous HTTP request by default. To make an 5552 asynchronous HTTP request, please define a `callback` function 5553 to be invoked when receiving the response. 5554 >>> def callback_function(response): 5555 >>> pprint(response) 5556 >>> 5557 >>> thread = api.list_permissions(account_id, callback=callback_function) 5558 5559 :param callback function: The callback function 5560 for asynchronous request. (optional) 5561 :param str account_id: The external account number (int) or account ID Guid. (required) 5562 :param str include: 5563 :return: PermissionProfileInformation 5564 If the method is called asynchronously, 5565 returns the request thread. 5566 """ 5567 kwargs['_return_http_data_only'] = True 5568 if kwargs.get('callback'): 5569 return self.list_permissions_with_http_info(account_id, **kwargs) 5570 else: 5571 (data) = self.list_permissions_with_http_info(account_id, **kwargs) 5572 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)
5574 def list_permissions_with_http_info(self, account_id, **kwargs): 5575 """ 5576 Gets a list of permission profiles. 5577 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. 5578 This method makes a synchronous HTTP request by default. To make an 5579 asynchronous HTTP request, please define a `callback` function 5580 to be invoked when receiving the response. 5581 >>> def callback_function(response): 5582 >>> pprint(response) 5583 >>> 5584 >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function) 5585 5586 :param callback function: The callback function 5587 for asynchronous request. (optional) 5588 :param str account_id: The external account number (int) or account ID Guid. (required) 5589 :param str include: 5590 :return: PermissionProfileInformation 5591 If the method is called asynchronously, 5592 returns the request thread. 5593 """ 5594 5595 all_params = ['account_id', 'include'] 5596 all_params.append('callback') 5597 all_params.append('_return_http_data_only') 5598 all_params.append('_preload_content') 5599 all_params.append('_request_timeout') 5600 5601 params = locals() 5602 for key, val in iteritems(params['kwargs']): 5603 if key not in all_params: 5604 raise TypeError( 5605 "Got an unexpected keyword argument '%s'" 5606 " to method list_permissions" % key 5607 ) 5608 params[key] = val 5609 del params['kwargs'] 5610 # verify the required parameter 'account_id' is set 5611 if ('account_id' not in params) or (params['account_id'] is None): 5612 raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`") 5613 5614 5615 collection_formats = {} 5616 5617 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 5618 path_params = {} 5619 if 'account_id' in params: 5620 path_params['accountId'] = params['account_id'] 5621 5622 query_params = {} 5623 if 'include' in params: 5624 query_params['include'] = params['include'] 5625 5626 header_params = {} 5627 5628 form_params = [] 5629 local_var_files = {} 5630 5631 body_params = None 5632 # HTTP header `Accept` 5633 header_params['Accept'] = self.api_client.\ 5634 select_header_accept(['application/json']) 5635 5636 # Authentication setting 5637 auth_settings = [] 5638 5639 return self.api_client.call_api(resource_path, 'GET', 5640 path_params, 5641 query_params, 5642 header_params, 5643 body=body_params, 5644 post_params=form_params, 5645 files=local_var_files, 5646 response_type='PermissionProfileInformation', 5647 auth_settings=auth_settings, 5648 callback=params.get('callback'), 5649 _return_http_data_only=params.get('_return_http_data_only'), 5650 _preload_content=params.get('_preload_content', True), 5651 _request_timeout=params.get('_request_timeout'), 5652 collection_formats=collection_formats)
Gets a list of permission profiles.
Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str include:
Returns
PermissionProfileInformation If the method is called asynchronously, returns the request thread.
def
list_recipient_names_by_email(self, account_id, **kwargs)
5654 def list_recipient_names_by_email(self, account_id, **kwargs): 5655 """ 5656 Gets recipient names associated with an email address. 5657 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5658 This method makes a synchronous HTTP request by default. To make an 5659 asynchronous HTTP request, please define a `callback` function 5660 to be invoked when receiving the response. 5661 >>> def callback_function(response): 5662 >>> pprint(response) 5663 >>> 5664 >>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function) 5665 5666 :param callback function: The callback function 5667 for asynchronous request. (optional) 5668 :param str account_id: The external account number (int) or account ID Guid. (required) 5669 :param str email: The email address for the user 5670 :return: RecipientNamesResponse 5671 If the method is called asynchronously, 5672 returns the request thread. 5673 """ 5674 kwargs['_return_http_data_only'] = True 5675 if kwargs.get('callback'): 5676 return self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5677 else: 5678 (data) = self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 5679 return data
Gets recipient names associated with an email address.
Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str email: The email address for the user
Returns
RecipientNamesResponse If the method is called asynchronously, returns the request thread.
def
list_recipient_names_by_email_with_http_info(self, account_id, **kwargs)
5681 def list_recipient_names_by_email_with_http_info(self, account_id, **kwargs): 5682 """ 5683 Gets recipient names associated with an email address. 5684 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 5685 This method makes a synchronous HTTP request by default. To make an 5686 asynchronous HTTP request, please define a `callback` function 5687 to be invoked when receiving the response. 5688 >>> def callback_function(response): 5689 >>> pprint(response) 5690 >>> 5691 >>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function) 5692 5693 :param callback function: The callback function 5694 for asynchronous request. (optional) 5695 :param str account_id: The external account number (int) or account ID Guid. (required) 5696 :param str email: The email address for the user 5697 :return: RecipientNamesResponse 5698 If the method is called asynchronously, 5699 returns the request thread. 5700 """ 5701 5702 all_params = ['account_id', 'email'] 5703 all_params.append('callback') 5704 all_params.append('_return_http_data_only') 5705 all_params.append('_preload_content') 5706 all_params.append('_request_timeout') 5707 5708 params = locals() 5709 for key, val in iteritems(params['kwargs']): 5710 if key not in all_params: 5711 raise TypeError( 5712 "Got an unexpected keyword argument '%s'" 5713 " to method list_recipient_names_by_email" % key 5714 ) 5715 params[key] = val 5716 del params['kwargs'] 5717 # verify the required parameter 'account_id' is set 5718 if ('account_id' not in params) or (params['account_id'] is None): 5719 raise ValueError("Missing the required parameter `account_id` when calling `list_recipient_names_by_email`") 5720 5721 5722 collection_formats = {} 5723 5724 resource_path = '/v2.1/accounts/{accountId}/recipient_names'.replace('{format}', 'json') 5725 path_params = {} 5726 if 'account_id' in params: 5727 path_params['accountId'] = params['account_id'] 5728 5729 query_params = {} 5730 if 'email' in params: 5731 query_params['email'] = params['email'] 5732 5733 header_params = {} 5734 5735 form_params = [] 5736 local_var_files = {} 5737 5738 body_params = None 5739 # HTTP header `Accept` 5740 header_params['Accept'] = self.api_client.\ 5741 select_header_accept(['application/json']) 5742 5743 # Authentication setting 5744 auth_settings = [] 5745 5746 return self.api_client.call_api(resource_path, 'GET', 5747 path_params, 5748 query_params, 5749 header_params, 5750 body=body_params, 5751 post_params=form_params, 5752 files=local_var_files, 5753 response_type='RecipientNamesResponse', 5754 auth_settings=auth_settings, 5755 callback=params.get('callback'), 5756 _return_http_data_only=params.get('_return_http_data_only'), 5757 _preload_content=params.get('_preload_content', True), 5758 _request_timeout=params.get('_request_timeout'), 5759 collection_formats=collection_formats)
Gets recipient names associated with an email address.
Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str email: The email address for the user
Returns
RecipientNamesResponse If the method is called asynchronously, returns the request thread.
def
list_settings(self, account_id, **kwargs)
5761 def list_settings(self, account_id, **kwargs): 5762 """ 5763 Gets account settings information. 5764 Retrieves the account settings information for the specified account. 5765 This method makes a synchronous HTTP request by default. To make an 5766 asynchronous HTTP request, please define a `callback` function 5767 to be invoked when receiving the response. 5768 >>> def callback_function(response): 5769 >>> pprint(response) 5770 >>> 5771 >>> thread = api.list_settings(account_id, callback=callback_function) 5772 5773 :param callback function: The callback function 5774 for asynchronous request. (optional) 5775 :param str account_id: The external account number (int) or account ID Guid. (required) 5776 :return: AccountSettingsInformation 5777 If the method is called asynchronously, 5778 returns the request thread. 5779 """ 5780 kwargs['_return_http_data_only'] = True 5781 if kwargs.get('callback'): 5782 return self.list_settings_with_http_info(account_id, **kwargs) 5783 else: 5784 (data) = self.list_settings_with_http_info(account_id, **kwargs) 5785 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)
5787 def list_settings_with_http_info(self, account_id, **kwargs): 5788 """ 5789 Gets account settings information. 5790 Retrieves the account settings information for the specified account. 5791 This method makes a synchronous HTTP request by default. To make an 5792 asynchronous HTTP request, please define a `callback` function 5793 to be invoked when receiving the response. 5794 >>> def callback_function(response): 5795 >>> pprint(response) 5796 >>> 5797 >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function) 5798 5799 :param callback function: The callback function 5800 for asynchronous request. (optional) 5801 :param str account_id: The external account number (int) or account ID Guid. (required) 5802 :return: AccountSettingsInformation 5803 If the method is called asynchronously, 5804 returns the request thread. 5805 """ 5806 5807 all_params = ['account_id'] 5808 all_params.append('callback') 5809 all_params.append('_return_http_data_only') 5810 all_params.append('_preload_content') 5811 all_params.append('_request_timeout') 5812 5813 params = locals() 5814 for key, val in iteritems(params['kwargs']): 5815 if key not in all_params: 5816 raise TypeError( 5817 "Got an unexpected keyword argument '%s'" 5818 " to method list_settings" % key 5819 ) 5820 params[key] = val 5821 del params['kwargs'] 5822 # verify the required parameter 'account_id' is set 5823 if ('account_id' not in params) or (params['account_id'] is None): 5824 raise ValueError("Missing the required parameter `account_id` when calling `list_settings`") 5825 5826 5827 collection_formats = {} 5828 5829 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 5830 path_params = {} 5831 if 'account_id' in params: 5832 path_params['accountId'] = params['account_id'] 5833 5834 query_params = {} 5835 5836 header_params = {} 5837 5838 form_params = [] 5839 local_var_files = {} 5840 5841 body_params = None 5842 # HTTP header `Accept` 5843 header_params['Accept'] = self.api_client.\ 5844 select_header_accept(['application/json']) 5845 5846 # Authentication setting 5847 auth_settings = [] 5848 5849 return self.api_client.call_api(resource_path, 'GET', 5850 path_params, 5851 query_params, 5852 header_params, 5853 body=body_params, 5854 post_params=form_params, 5855 files=local_var_files, 5856 response_type='AccountSettingsInformation', 5857 auth_settings=auth_settings, 5858 callback=params.get('callback'), 5859 _return_http_data_only=params.get('_return_http_data_only'), 5860 _preload_content=params.get('_preload_content', True), 5861 _request_timeout=params.get('_request_timeout'), 5862 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)
5999 def list_signature_providers(self, account_id, **kwargs): 6000 """ 6001 Returns Account available signature providers for specified account. 6002 Returns a list of signature providers that the specified account can use. 6003 This method makes a synchronous HTTP request by default. To make an 6004 asynchronous HTTP request, please define a `callback` function 6005 to be invoked when receiving the response. 6006 >>> def callback_function(response): 6007 >>> pprint(response) 6008 >>> 6009 >>> thread = api.list_signature_providers(account_id, callback=callback_function) 6010 6011 :param callback function: The callback function 6012 for asynchronous request. (optional) 6013 :param str account_id: The external account number (int) or account ID Guid. (required) 6014 :return: AccountSignatureProviders 6015 If the method is called asynchronously, 6016 returns the request thread. 6017 """ 6018 kwargs['_return_http_data_only'] = True 6019 if kwargs.get('callback'): 6020 return self.list_signature_providers_with_http_info(account_id, **kwargs) 6021 else: 6022 (data) = self.list_signature_providers_with_http_info(account_id, **kwargs) 6023 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)
6025 def list_signature_providers_with_http_info(self, account_id, **kwargs): 6026 """ 6027 Returns Account available signature providers for specified account. 6028 Returns a list of signature providers that the specified account can use. 6029 This method makes a synchronous HTTP request by default. To make an 6030 asynchronous HTTP request, please define a `callback` function 6031 to be invoked when receiving the response. 6032 >>> def callback_function(response): 6033 >>> pprint(response) 6034 >>> 6035 >>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function) 6036 6037 :param callback function: The callback function 6038 for asynchronous request. (optional) 6039 :param str account_id: The external account number (int) or account ID Guid. (required) 6040 :return: AccountSignatureProviders 6041 If the method is called asynchronously, 6042 returns the request thread. 6043 """ 6044 6045 all_params = ['account_id'] 6046 all_params.append('callback') 6047 all_params.append('_return_http_data_only') 6048 all_params.append('_preload_content') 6049 all_params.append('_request_timeout') 6050 6051 params = locals() 6052 for key, val in iteritems(params['kwargs']): 6053 if key not in all_params: 6054 raise TypeError( 6055 "Got an unexpected keyword argument '%s'" 6056 " to method list_signature_providers" % key 6057 ) 6058 params[key] = val 6059 del params['kwargs'] 6060 # verify the required parameter 'account_id' is set 6061 if ('account_id' not in params) or (params['account_id'] is None): 6062 raise ValueError("Missing the required parameter `account_id` when calling `list_signature_providers`") 6063 6064 6065 collection_formats = {} 6066 6067 resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.replace('{format}', 'json') 6068 path_params = {} 6069 if 'account_id' in params: 6070 path_params['accountId'] = params['account_id'] 6071 6072 query_params = {} 6073 6074 header_params = {} 6075 6076 form_params = [] 6077 local_var_files = {} 6078 6079 body_params = None 6080 # HTTP header `Accept` 6081 header_params['Accept'] = self.api_client.\ 6082 select_header_accept(['application/json']) 6083 6084 # Authentication setting 6085 auth_settings = [] 6086 6087 return self.api_client.call_api(resource_path, 'GET', 6088 path_params, 6089 query_params, 6090 header_params, 6091 body=body_params, 6092 post_params=form_params, 6093 files=local_var_files, 6094 response_type='AccountSignatureProviders', 6095 auth_settings=auth_settings, 6096 callback=params.get('callback'), 6097 _return_http_data_only=params.get('_return_http_data_only'), 6098 _preload_content=params.get('_preload_content', True), 6099 _request_timeout=params.get('_request_timeout'), 6100 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)
6102 def list_unsupported_file_types(self, account_id, **kwargs): 6103 """ 6104 Gets a list of unsupported file types. 6105 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6106 This method makes a synchronous HTTP request by default. To make an 6107 asynchronous HTTP request, please define a `callback` function 6108 to be invoked when receiving the response. 6109 >>> def callback_function(response): 6110 >>> pprint(response) 6111 >>> 6112 >>> thread = api.list_unsupported_file_types(account_id, callback=callback_function) 6113 6114 :param callback function: The callback function 6115 for asynchronous request. (optional) 6116 :param str account_id: The external account number (int) or account ID Guid. (required) 6117 :return: FileTypeList 6118 If the method is called asynchronously, 6119 returns the request thread. 6120 """ 6121 kwargs['_return_http_data_only'] = True 6122 if kwargs.get('callback'): 6123 return self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6124 else: 6125 (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 6126 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)
6128 def list_unsupported_file_types_with_http_info(self, account_id, **kwargs): 6129 """ 6130 Gets a list of unsupported file types. 6131 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 6132 This method makes a synchronous HTTP request by default. To make an 6133 asynchronous HTTP request, please define a `callback` function 6134 to be invoked when receiving the response. 6135 >>> def callback_function(response): 6136 >>> pprint(response) 6137 >>> 6138 >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function) 6139 6140 :param callback function: The callback function 6141 for asynchronous request. (optional) 6142 :param str account_id: The external account number (int) or account ID Guid. (required) 6143 :return: FileTypeList 6144 If the method is called asynchronously, 6145 returns the request thread. 6146 """ 6147 6148 all_params = ['account_id'] 6149 all_params.append('callback') 6150 all_params.append('_return_http_data_only') 6151 all_params.append('_preload_content') 6152 all_params.append('_request_timeout') 6153 6154 params = locals() 6155 for key, val in iteritems(params['kwargs']): 6156 if key not in all_params: 6157 raise TypeError( 6158 "Got an unexpected keyword argument '%s'" 6159 " to method list_unsupported_file_types" % key 6160 ) 6161 params[key] = val 6162 del params['kwargs'] 6163 # verify the required parameter 'account_id' is set 6164 if ('account_id' not in params) or (params['account_id'] is None): 6165 raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`") 6166 6167 6168 collection_formats = {} 6169 6170 resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json') 6171 path_params = {} 6172 if 'account_id' in params: 6173 path_params['accountId'] = params['account_id'] 6174 6175 query_params = {} 6176 6177 header_params = {} 6178 6179 form_params = [] 6180 local_var_files = {} 6181 6182 body_params = None 6183 # HTTP header `Accept` 6184 header_params['Accept'] = self.api_client.\ 6185 select_header_accept(['application/json']) 6186 6187 # Authentication setting 6188 auth_settings = [] 6189 6190 return self.api_client.call_api(resource_path, 'GET', 6191 path_params, 6192 query_params, 6193 header_params, 6194 body=body_params, 6195 post_params=form_params, 6196 files=local_var_files, 6197 response_type='FileTypeList', 6198 auth_settings=auth_settings, 6199 callback=params.get('callback'), 6200 _return_http_data_only=params.get('_return_http_data_only'), 6201 _preload_content=params.get('_preload_content', True), 6202 _request_timeout=params.get('_request_timeout'), 6203 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)
6205 def un_favorite_template(self, account_id, **kwargs): 6206 """ 6207 Unfavorite a template 6208 6209 This method makes a synchronous HTTP request by default. To make an 6210 asynchronous HTTP request, please define a `callback` function 6211 to be invoked when receiving the response. 6212 >>> def callback_function(response): 6213 >>> pprint(response) 6214 >>> 6215 >>> thread = api.un_favorite_template(account_id, callback=callback_function) 6216 6217 :param callback function: The callback function 6218 for asynchronous request. (optional) 6219 :param str account_id: The external account number (int) or account ID Guid. (required) 6220 :param FavoriteTemplatesInfo favorite_templates_info: 6221 :return: FavoriteTemplatesInfo 6222 If the method is called asynchronously, 6223 returns the request thread. 6224 """ 6225 kwargs['_return_http_data_only'] = True 6226 if kwargs.get('callback'): 6227 return self.un_favorite_template_with_http_info(account_id, **kwargs) 6228 else: 6229 (data) = self.un_favorite_template_with_http_info(account_id, **kwargs) 6230 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)
6232 def un_favorite_template_with_http_info(self, account_id, **kwargs): 6233 """ 6234 Unfavorite a template 6235 6236 This method makes a synchronous HTTP request by default. To make an 6237 asynchronous HTTP request, please define a `callback` function 6238 to be invoked when receiving the response. 6239 >>> def callback_function(response): 6240 >>> pprint(response) 6241 >>> 6242 >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function) 6243 6244 :param callback function: The callback function 6245 for asynchronous request. (optional) 6246 :param str account_id: The external account number (int) or account ID Guid. (required) 6247 :param FavoriteTemplatesInfo favorite_templates_info: 6248 :return: FavoriteTemplatesInfo 6249 If the method is called asynchronously, 6250 returns the request thread. 6251 """ 6252 6253 all_params = ['account_id', 'favorite_templates_info'] 6254 all_params.append('callback') 6255 all_params.append('_return_http_data_only') 6256 all_params.append('_preload_content') 6257 all_params.append('_request_timeout') 6258 6259 params = locals() 6260 for key, val in iteritems(params['kwargs']): 6261 if key not in all_params: 6262 raise TypeError( 6263 "Got an unexpected keyword argument '%s'" 6264 " to method un_favorite_template" % key 6265 ) 6266 params[key] = val 6267 del params['kwargs'] 6268 # verify the required parameter 'account_id' is set 6269 if ('account_id' not in params) or (params['account_id'] is None): 6270 raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`") 6271 6272 6273 collection_formats = {} 6274 6275 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 6276 path_params = {} 6277 if 'account_id' in params: 6278 path_params['accountId'] = params['account_id'] 6279 6280 query_params = {} 6281 6282 header_params = {} 6283 6284 form_params = [] 6285 local_var_files = {} 6286 6287 body_params = None 6288 if 'favorite_templates_info' in params: 6289 body_params = params['favorite_templates_info'] 6290 # HTTP header `Accept` 6291 header_params['Accept'] = self.api_client.\ 6292 select_header_accept(['application/json']) 6293 6294 # Authentication setting 6295 auth_settings = [] 6296 6297 return self.api_client.call_api(resource_path, 'DELETE', 6298 path_params, 6299 query_params, 6300 header_params, 6301 body=body_params, 6302 post_params=form_params, 6303 files=local_var_files, 6304 response_type='FavoriteTemplatesInfo', 6305 auth_settings=auth_settings, 6306 callback=params.get('callback'), 6307 _return_http_data_only=params.get('_return_http_data_only'), 6308 _preload_content=params.get('_preload_content', True), 6309 _request_timeout=params.get('_request_timeout'), 6310 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)
6312 def update_account_signature(self, account_id, **kwargs): 6313 """ 6314 Updates a account signature. 6315 6316 This method makes a synchronous HTTP request by default. To make an 6317 asynchronous HTTP request, please define a `callback` function 6318 to be invoked when receiving the response. 6319 >>> def callback_function(response): 6320 >>> pprint(response) 6321 >>> 6322 >>> thread = api.update_account_signature(account_id, callback=callback_function) 6323 6324 :param callback function: The callback function 6325 for asynchronous request. (optional) 6326 :param str account_id: The external account number (int) or account ID Guid. (required) 6327 :param AccountSignaturesInformation account_signatures_information: 6328 :return: AccountSignaturesInformation 6329 If the method is called asynchronously, 6330 returns the request thread. 6331 """ 6332 kwargs['_return_http_data_only'] = True 6333 if kwargs.get('callback'): 6334 return self.update_account_signature_with_http_info(account_id, **kwargs) 6335 else: 6336 (data) = self.update_account_signature_with_http_info(account_id, **kwargs) 6337 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)
6339 def update_account_signature_with_http_info(self, account_id, **kwargs): 6340 """ 6341 Updates a account signature. 6342 6343 This method makes a synchronous HTTP request by default. To make an 6344 asynchronous HTTP request, please define a `callback` function 6345 to be invoked when receiving the response. 6346 >>> def callback_function(response): 6347 >>> pprint(response) 6348 >>> 6349 >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function) 6350 6351 :param callback function: The callback function 6352 for asynchronous request. (optional) 6353 :param str account_id: The external account number (int) or account ID Guid. (required) 6354 :param AccountSignaturesInformation account_signatures_information: 6355 :return: AccountSignaturesInformation 6356 If the method is called asynchronously, 6357 returns the request thread. 6358 """ 6359 6360 all_params = ['account_id', 'account_signatures_information'] 6361 all_params.append('callback') 6362 all_params.append('_return_http_data_only') 6363 all_params.append('_preload_content') 6364 all_params.append('_request_timeout') 6365 6366 params = locals() 6367 for key, val in iteritems(params['kwargs']): 6368 if key not in all_params: 6369 raise TypeError( 6370 "Got an unexpected keyword argument '%s'" 6371 " to method update_account_signature" % key 6372 ) 6373 params[key] = val 6374 del params['kwargs'] 6375 # verify the required parameter 'account_id' is set 6376 if ('account_id' not in params) or (params['account_id'] is None): 6377 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`") 6378 6379 6380 collection_formats = {} 6381 6382 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 6383 path_params = {} 6384 if 'account_id' in params: 6385 path_params['accountId'] = params['account_id'] 6386 6387 query_params = {} 6388 6389 header_params = {} 6390 6391 form_params = [] 6392 local_var_files = {} 6393 6394 body_params = None 6395 if 'account_signatures_information' in params: 6396 body_params = params['account_signatures_information'] 6397 # HTTP header `Accept` 6398 header_params['Accept'] = self.api_client.\ 6399 select_header_accept(['application/json']) 6400 6401 # Authentication setting 6402 auth_settings = [] 6403 6404 return self.api_client.call_api(resource_path, 'PUT', 6405 path_params, 6406 query_params, 6407 header_params, 6408 body=body_params, 6409 post_params=form_params, 6410 files=local_var_files, 6411 response_type='AccountSignaturesInformation', 6412 auth_settings=auth_settings, 6413 callback=params.get('callback'), 6414 _return_http_data_only=params.get('_return_http_data_only'), 6415 _preload_content=params.get('_preload_content', True), 6416 _request_timeout=params.get('_request_timeout'), 6417 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)
6419 def update_account_signature_by_id(self, account_id, signature_id, **kwargs): 6420 """ 6421 Updates a account signature. 6422 6423 This method makes a synchronous HTTP request by default. To make an 6424 asynchronous HTTP request, please define a `callback` function 6425 to be invoked when receiving the response. 6426 >>> def callback_function(response): 6427 >>> pprint(response) 6428 >>> 6429 >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function) 6430 6431 :param callback function: The callback function 6432 for asynchronous request. (optional) 6433 :param str account_id: The external account number (int) or account ID Guid. (required) 6434 :param str signature_id: The ID of the signature being accessed. (required) 6435 :param str close_existing_signature: 6436 :param AccountSignatureDefinition account_signature_definition: 6437 :return: AccountSignature 6438 If the method is called asynchronously, 6439 returns the request thread. 6440 """ 6441 kwargs['_return_http_data_only'] = True 6442 if kwargs.get('callback'): 6443 return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6444 else: 6445 (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 6446 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)
6448 def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs): 6449 """ 6450 Updates a account signature. 6451 6452 This method makes a synchronous HTTP request by default. To make an 6453 asynchronous HTTP request, please define a `callback` function 6454 to be invoked when receiving the response. 6455 >>> def callback_function(response): 6456 >>> pprint(response) 6457 >>> 6458 >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function) 6459 6460 :param callback function: The callback function 6461 for asynchronous request. (optional) 6462 :param str account_id: The external account number (int) or account ID Guid. (required) 6463 :param str signature_id: The ID of the signature being accessed. (required) 6464 :param str close_existing_signature: 6465 :param AccountSignatureDefinition account_signature_definition: 6466 :return: AccountSignature 6467 If the method is called asynchronously, 6468 returns the request thread. 6469 """ 6470 6471 all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition'] 6472 all_params.append('callback') 6473 all_params.append('_return_http_data_only') 6474 all_params.append('_preload_content') 6475 all_params.append('_request_timeout') 6476 6477 params = locals() 6478 for key, val in iteritems(params['kwargs']): 6479 if key not in all_params: 6480 raise TypeError( 6481 "Got an unexpected keyword argument '%s'" 6482 " to method update_account_signature_by_id" % key 6483 ) 6484 params[key] = val 6485 del params['kwargs'] 6486 # verify the required parameter 'account_id' is set 6487 if ('account_id' not in params) or (params['account_id'] is None): 6488 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`") 6489 # verify the required parameter 'signature_id' is set 6490 if ('signature_id' not in params) or (params['signature_id'] is None): 6491 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`") 6492 6493 6494 collection_formats = {} 6495 6496 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 6497 path_params = {} 6498 if 'account_id' in params: 6499 path_params['accountId'] = params['account_id'] 6500 if 'signature_id' in params: 6501 path_params['signatureId'] = params['signature_id'] 6502 6503 query_params = {} 6504 if 'close_existing_signature' in params: 6505 query_params['close_existing_signature'] = params['close_existing_signature'] 6506 6507 header_params = {} 6508 6509 form_params = [] 6510 local_var_files = {} 6511 6512 body_params = None 6513 if 'account_signature_definition' in params: 6514 body_params = params['account_signature_definition'] 6515 # HTTP header `Accept` 6516 header_params['Accept'] = self.api_client.\ 6517 select_header_accept(['application/json']) 6518 6519 # Authentication setting 6520 auth_settings = [] 6521 6522 return self.api_client.call_api(resource_path, 'PUT', 6523 path_params, 6524 query_params, 6525 header_params, 6526 body=body_params, 6527 post_params=form_params, 6528 files=local_var_files, 6529 response_type='AccountSignature', 6530 auth_settings=auth_settings, 6531 callback=params.get('callback'), 6532 _return_http_data_only=params.get('_return_http_data_only'), 6533 _preload_content=params.get('_preload_content', True), 6534 _request_timeout=params.get('_request_timeout'), 6535 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)
6537 def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 6538 """ 6539 Sets a signature, initials, or stamps image. 6540 6541 This method makes a synchronous HTTP request by default. To make an 6542 asynchronous HTTP request, please define a `callback` function 6543 to be invoked when receiving the response. 6544 >>> def callback_function(response): 6545 >>> pprint(response) 6546 >>> 6547 >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 6548 6549 :param callback function: The callback function 6550 for asynchronous request. (optional) 6551 :param str account_id: The external account number (int) or account ID Guid. (required) 6552 :param str image_type: One of **signature_image** or **initials_image**. (required) 6553 :param str signature_id: The ID of the signature being accessed. (required) 6554 :param str transparent_png: 6555 :return: AccountSignature 6556 If the method is called asynchronously, 6557 returns the request thread. 6558 """ 6559 kwargs['_return_http_data_only'] = True 6560 if kwargs.get('callback'): 6561 return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6562 else: 6563 (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 6564 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)
6566 def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 6567 """ 6568 Sets a signature, initials, or stamps image. 6569 6570 This method makes a synchronous HTTP request by default. To make an 6571 asynchronous HTTP request, please define a `callback` function 6572 to be invoked when receiving the response. 6573 >>> def callback_function(response): 6574 >>> pprint(response) 6575 >>> 6576 >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 6577 6578 :param callback function: The callback function 6579 for asynchronous request. (optional) 6580 :param str account_id: The external account number (int) or account ID Guid. (required) 6581 :param str image_type: One of **signature_image** or **initials_image**. (required) 6582 :param str signature_id: The ID of the signature being accessed. (required) 6583 :param str transparent_png: 6584 :return: AccountSignature 6585 If the method is called asynchronously, 6586 returns the request thread. 6587 """ 6588 6589 all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png'] 6590 all_params.append('callback') 6591 all_params.append('_return_http_data_only') 6592 all_params.append('_preload_content') 6593 all_params.append('_request_timeout') 6594 6595 params = locals() 6596 for key, val in iteritems(params['kwargs']): 6597 if key not in all_params: 6598 raise TypeError( 6599 "Got an unexpected keyword argument '%s'" 6600 " to method update_account_signature_image" % key 6601 ) 6602 params[key] = val 6603 del params['kwargs'] 6604 # verify the required parameter 'account_id' is set 6605 if ('account_id' not in params) or (params['account_id'] is None): 6606 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`") 6607 # verify the required parameter 'image_type' is set 6608 if ('image_type' not in params) or (params['image_type'] is None): 6609 raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`") 6610 # verify the required parameter 'signature_id' is set 6611 if ('signature_id' not in params) or (params['signature_id'] is None): 6612 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`") 6613 6614 6615 collection_formats = {} 6616 6617 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 6618 path_params = {} 6619 if 'account_id' in params: 6620 path_params['accountId'] = params['account_id'] 6621 if 'image_type' in params: 6622 path_params['imageType'] = params['image_type'] 6623 if 'signature_id' in params: 6624 path_params['signatureId'] = params['signature_id'] 6625 6626 query_params = {} 6627 if 'transparent_png' in params: 6628 query_params['transparent_png'] = params['transparent_png'] 6629 6630 header_params = {} 6631 6632 form_params = [] 6633 local_var_files = {} 6634 6635 body_params = None 6636 # HTTP header `Accept` 6637 header_params['Accept'] = self.api_client.\ 6638 select_header_accept(['application/json']) 6639 6640 # HTTP header `Content-Type` 6641 header_params['Content-Type'] = self.api_client.\ 6642 select_header_content_type(['image/gif']) 6643 6644 # Authentication setting 6645 auth_settings = [] 6646 6647 return self.api_client.call_api(resource_path, 'PUT', 6648 path_params, 6649 query_params, 6650 header_params, 6651 body=body_params, 6652 post_params=form_params, 6653 files=local_var_files, 6654 response_type='AccountSignature', 6655 auth_settings=auth_settings, 6656 callback=params.get('callback'), 6657 _return_http_data_only=params.get('_return_http_data_only'), 6658 _preload_content=params.get('_preload_content', True), 6659 _request_timeout=params.get('_request_timeout'), 6660 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)
6662 def update_account_tab_settings(self, account_id, **kwargs): 6663 """ 6664 Modifies tab settings for specified account 6665 This method modifies the tab types and tab functionality that is enabled for an account. 6666 This method makes a synchronous HTTP request by default. To make an 6667 asynchronous HTTP request, please define a `callback` function 6668 to be invoked when receiving the response. 6669 >>> def callback_function(response): 6670 >>> pprint(response) 6671 >>> 6672 >>> thread = api.update_account_tab_settings(account_id, callback=callback_function) 6673 6674 :param callback function: The callback function 6675 for asynchronous request. (optional) 6676 :param str account_id: The external account number (int) or account ID Guid. (required) 6677 :param TabAccountSettings tab_account_settings: 6678 :return: TabAccountSettings 6679 If the method is called asynchronously, 6680 returns the request thread. 6681 """ 6682 kwargs['_return_http_data_only'] = True 6683 if kwargs.get('callback'): 6684 return self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6685 else: 6686 (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs) 6687 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)
6689 def update_account_tab_settings_with_http_info(self, account_id, **kwargs): 6690 """ 6691 Modifies tab settings for specified account 6692 This method modifies the tab types and tab functionality that is enabled for an account. 6693 This method makes a synchronous HTTP request by default. To make an 6694 asynchronous HTTP request, please define a `callback` function 6695 to be invoked when receiving the response. 6696 >>> def callback_function(response): 6697 >>> pprint(response) 6698 >>> 6699 >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function) 6700 6701 :param callback function: The callback function 6702 for asynchronous request. (optional) 6703 :param str account_id: The external account number (int) or account ID Guid. (required) 6704 :param TabAccountSettings tab_account_settings: 6705 :return: TabAccountSettings 6706 If the method is called asynchronously, 6707 returns the request thread. 6708 """ 6709 6710 all_params = ['account_id', 'tab_account_settings'] 6711 all_params.append('callback') 6712 all_params.append('_return_http_data_only') 6713 all_params.append('_preload_content') 6714 all_params.append('_request_timeout') 6715 6716 params = locals() 6717 for key, val in iteritems(params['kwargs']): 6718 if key not in all_params: 6719 raise TypeError( 6720 "Got an unexpected keyword argument '%s'" 6721 " to method update_account_tab_settings" % key 6722 ) 6723 params[key] = val 6724 del params['kwargs'] 6725 # verify the required parameter 'account_id' is set 6726 if ('account_id' not in params) or (params['account_id'] is None): 6727 raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`") 6728 6729 6730 collection_formats = {} 6731 6732 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 6733 path_params = {} 6734 if 'account_id' in params: 6735 path_params['accountId'] = params['account_id'] 6736 6737 query_params = {} 6738 6739 header_params = {} 6740 6741 form_params = [] 6742 local_var_files = {} 6743 6744 body_params = None 6745 if 'tab_account_settings' in params: 6746 body_params = params['tab_account_settings'] 6747 # HTTP header `Accept` 6748 header_params['Accept'] = self.api_client.\ 6749 select_header_accept(['application/json']) 6750 6751 # Authentication setting 6752 auth_settings = [] 6753 6754 return self.api_client.call_api(resource_path, 'PUT', 6755 path_params, 6756 query_params, 6757 header_params, 6758 body=body_params, 6759 post_params=form_params, 6760 files=local_var_files, 6761 response_type='TabAccountSettings', 6762 auth_settings=auth_settings, 6763 callback=params.get('callback'), 6764 _return_http_data_only=params.get('_return_http_data_only'), 6765 _preload_content=params.get('_preload_content', True), 6766 _request_timeout=params.get('_request_timeout'), 6767 collection_formats=collection_formats)
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)
6769 def update_brand(self, account_id, brand_id, **kwargs): 6770 """ 6771 Updates an existing brand. 6772 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**). 6773 This method makes a synchronous HTTP request by default. To make an 6774 asynchronous HTTP request, please define a `callback` function 6775 to be invoked when receiving the response. 6776 >>> def callback_function(response): 6777 >>> pprint(response) 6778 >>> 6779 >>> thread = api.update_brand(account_id, brand_id, callback=callback_function) 6780 6781 :param callback function: The callback function 6782 for asynchronous request. (optional) 6783 :param str account_id: The external account number (int) or account ID Guid. (required) 6784 :param str brand_id: The unique identifier of a brand. (required) 6785 :param str replace_brand: 6786 :param Brand brand: 6787 :return: Brand 6788 If the method is called asynchronously, 6789 returns the request thread. 6790 """ 6791 kwargs['_return_http_data_only'] = True 6792 if kwargs.get('callback'): 6793 return self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6794 else: 6795 (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs) 6796 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)
6798 def update_brand_with_http_info(self, account_id, brand_id, **kwargs): 6799 """ 6800 Updates an existing brand. 6801 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**). 6802 This method makes a synchronous HTTP request by default. To make an 6803 asynchronous HTTP request, please define a `callback` function 6804 to be invoked when receiving the response. 6805 >>> def callback_function(response): 6806 >>> pprint(response) 6807 >>> 6808 >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function) 6809 6810 :param callback function: The callback function 6811 for asynchronous request. (optional) 6812 :param str account_id: The external account number (int) or account ID Guid. (required) 6813 :param str brand_id: The unique identifier of a brand. (required) 6814 :param str replace_brand: 6815 :param Brand brand: 6816 :return: Brand 6817 If the method is called asynchronously, 6818 returns the request thread. 6819 """ 6820 6821 all_params = ['account_id', 'brand_id', 'replace_brand', 'brand'] 6822 all_params.append('callback') 6823 all_params.append('_return_http_data_only') 6824 all_params.append('_preload_content') 6825 all_params.append('_request_timeout') 6826 6827 params = locals() 6828 for key, val in iteritems(params['kwargs']): 6829 if key not in all_params: 6830 raise TypeError( 6831 "Got an unexpected keyword argument '%s'" 6832 " to method update_brand" % key 6833 ) 6834 params[key] = val 6835 del params['kwargs'] 6836 # verify the required parameter 'account_id' is set 6837 if ('account_id' not in params) or (params['account_id'] is None): 6838 raise ValueError("Missing the required parameter `account_id` when calling `update_brand`") 6839 # verify the required parameter 'brand_id' is set 6840 if ('brand_id' not in params) or (params['brand_id'] is None): 6841 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`") 6842 6843 6844 collection_formats = {} 6845 6846 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 6847 path_params = {} 6848 if 'account_id' in params: 6849 path_params['accountId'] = params['account_id'] 6850 if 'brand_id' in params: 6851 path_params['brandId'] = params['brand_id'] 6852 6853 query_params = {} 6854 if 'replace_brand' in params: 6855 query_params['replace_brand'] = params['replace_brand'] 6856 6857 header_params = {} 6858 6859 form_params = [] 6860 local_var_files = {} 6861 6862 body_params = None 6863 if 'brand' in params: 6864 body_params = params['brand'] 6865 # HTTP header `Accept` 6866 header_params['Accept'] = self.api_client.\ 6867 select_header_accept(['application/json']) 6868 6869 # Authentication setting 6870 auth_settings = [] 6871 6872 return self.api_client.call_api(resource_path, 'PUT', 6873 path_params, 6874 query_params, 6875 header_params, 6876 body=body_params, 6877 post_params=form_params, 6878 files=local_var_files, 6879 response_type='Brand', 6880 auth_settings=auth_settings, 6881 callback=params.get('callback'), 6882 _return_http_data_only=params.get('_return_http_data_only'), 6883 _preload_content=params.get('_preload_content', True), 6884 _request_timeout=params.get('_request_timeout'), 6885 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)
6887 def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6888 """ 6889 Put one branding logo. 6890 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**). 6891 This method makes a synchronous HTTP request by default. To make an 6892 asynchronous HTTP request, please define a `callback` function 6893 to be invoked when receiving the response. 6894 >>> def callback_function(response): 6895 >>> pprint(response) 6896 >>> 6897 >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6898 6899 :param callback function: The callback function 6900 for asynchronous request. (optional) 6901 :param str account_id: The external account number (int) or account ID GUID. (required) 6902 :param str brand_id: The ID of the brand. (required) 6903 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6904 :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) 6905 :return: None 6906 If the method is called asynchronously, 6907 returns the request thread. 6908 """ 6909 kwargs['_return_http_data_only'] = True 6910 if kwargs.get('callback'): 6911 return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6912 else: 6913 (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6914 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)
6916 def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6917 """ 6918 Put one branding logo. 6919 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**). 6920 This method makes a synchronous HTTP request by default. To make an 6921 asynchronous HTTP request, please define a `callback` function 6922 to be invoked when receiving the response. 6923 >>> def callback_function(response): 6924 >>> pprint(response) 6925 >>> 6926 >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6927 6928 :param callback function: The callback function 6929 for asynchronous request. (optional) 6930 :param str account_id: The external account number (int) or account ID GUID. (required) 6931 :param str brand_id: The ID of the brand. (required) 6932 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6933 :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) 6934 :return: None 6935 If the method is called asynchronously, 6936 returns the request thread. 6937 """ 6938 6939 all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes'] 6940 all_params.append('callback') 6941 all_params.append('_return_http_data_only') 6942 all_params.append('_preload_content') 6943 all_params.append('_request_timeout') 6944 6945 params = locals() 6946 for key, val in iteritems(params['kwargs']): 6947 if key not in all_params: 6948 raise TypeError( 6949 "Got an unexpected keyword argument '%s'" 6950 " to method update_brand_logo_by_type" % key 6951 ) 6952 params[key] = val 6953 del params['kwargs'] 6954 # verify the required parameter 'account_id' is set 6955 if ('account_id' not in params) or (params['account_id'] is None): 6956 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`") 6957 # verify the required parameter 'brand_id' is set 6958 if ('brand_id' not in params) or (params['brand_id'] is None): 6959 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`") 6960 # verify the required parameter 'logo_type' is set 6961 if ('logo_type' not in params) or (params['logo_type'] is None): 6962 raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`") 6963 # verify the required parameter 'logo_file_bytes' is set 6964 if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None): 6965 raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`") 6966 6967 6968 collection_formats = {} 6969 6970 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 6971 path_params = {} 6972 if 'account_id' in params: 6973 path_params['accountId'] = params['account_id'] 6974 if 'brand_id' in params: 6975 path_params['brandId'] = params['brand_id'] 6976 if 'logo_type' in params: 6977 path_params['logoType'] = params['logo_type'] 6978 6979 query_params = {} 6980 6981 header_params = {} 6982 6983 form_params = [] 6984 local_var_files = {} 6985 6986 body_params = None 6987 if 'logo_file_bytes' in params: 6988 body_params = params['logo_file_bytes'] 6989 # HTTP header `Accept` 6990 header_params['Accept'] = self.api_client.\ 6991 select_header_accept(['application/json']) 6992 6993 # HTTP header `Content-Type` 6994 header_params['Content-Type'] = self.api_client.\ 6995 select_header_content_type(['image/png']) 6996 6997 # Authentication setting 6998 auth_settings = [] 6999 7000 return self.api_client.call_api(resource_path, 'PUT', 7001 path_params, 7002 query_params, 7003 header_params, 7004 body=body_params, 7005 post_params=form_params, 7006 files=local_var_files, 7007 response_type=None, 7008 auth_settings=auth_settings, 7009 callback=params.get('callback'), 7010 _return_http_data_only=params.get('_return_http_data_only'), 7011 _preload_content=params.get('_preload_content', True), 7012 _request_timeout=params.get('_request_timeout'), 7013 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)
7015 def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7016 """ 7017 Uploads a branding resource file. 7018 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. 7019 This method makes a synchronous HTTP request by default. To make an 7020 asynchronous HTTP request, please define a `callback` function 7021 to be invoked when receiving the response. 7022 >>> def callback_function(response): 7023 >>> pprint(response) 7024 >>> 7025 >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7026 7027 :param callback function: The callback function 7028 for asynchronous request. (optional) 7029 :param str account_id: The external account number (int) or account ID GUID. (required) 7030 :param str brand_id: The ID of the brand. (required) 7031 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7032 :param file file_xml: Brand resource XML file. (required) 7033 :return: BrandResources 7034 If the method is called asynchronously, 7035 returns the request thread. 7036 """ 7037 kwargs['_return_http_data_only'] = True 7038 if kwargs.get('callback'): 7039 return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7040 else: 7041 (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 7042 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)
7044 def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 7045 """ 7046 Uploads a branding resource file. 7047 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. 7048 This method makes a synchronous HTTP request by default. To make an 7049 asynchronous HTTP request, please define a `callback` function 7050 to be invoked when receiving the response. 7051 >>> def callback_function(response): 7052 >>> pprint(response) 7053 >>> 7054 >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 7055 7056 :param callback function: The callback function 7057 for asynchronous request. (optional) 7058 :param str account_id: The external account number (int) or account ID GUID. (required) 7059 :param str brand_id: The ID of the brand. (required) 7060 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 7061 :param file file_xml: Brand resource XML file. (required) 7062 :return: BrandResources 7063 If the method is called asynchronously, 7064 returns the request thread. 7065 """ 7066 7067 all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml'] 7068 all_params.append('callback') 7069 all_params.append('_return_http_data_only') 7070 all_params.append('_preload_content') 7071 all_params.append('_request_timeout') 7072 7073 params = locals() 7074 for key, val in iteritems(params['kwargs']): 7075 if key not in all_params: 7076 raise TypeError( 7077 "Got an unexpected keyword argument '%s'" 7078 " to method update_brand_resources_by_content_type" % key 7079 ) 7080 params[key] = val 7081 del params['kwargs'] 7082 # verify the required parameter 'account_id' is set 7083 if ('account_id' not in params) or (params['account_id'] is None): 7084 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`") 7085 # verify the required parameter 'brand_id' is set 7086 if ('brand_id' not in params) or (params['brand_id'] is None): 7087 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`") 7088 # verify the required parameter 'resource_content_type' is set 7089 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 7090 raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`") 7091 # verify the required parameter 'file_xml' is set 7092 if ('file_xml' not in params) or (params['file_xml'] is None): 7093 raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`") 7094 7095 7096 collection_formats = {} 7097 7098 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 7099 path_params = {} 7100 if 'account_id' in params: 7101 path_params['accountId'] = params['account_id'] 7102 if 'brand_id' in params: 7103 path_params['brandId'] = params['brand_id'] 7104 if 'resource_content_type' in params: 7105 path_params['resourceContentType'] = params['resource_content_type'] 7106 7107 query_params = {} 7108 7109 header_params = {} 7110 7111 form_params = [] 7112 local_var_files = {} 7113 if 'file_xml' in params: 7114 local_var_files['file.xml'] = params['file_xml'] 7115 7116 body_params = None 7117 # HTTP header `Accept` 7118 header_params['Accept'] = self.api_client.\ 7119 select_header_accept(['application/json']) 7120 7121 # HTTP header `Content-Type` 7122 header_params['Content-Type'] = self.api_client.\ 7123 select_header_content_type(['multipart/form-data']) 7124 7125 # Authentication setting 7126 auth_settings = [] 7127 7128 return self.api_client.call_api(resource_path, 'PUT', 7129 path_params, 7130 query_params, 7131 header_params, 7132 body=body_params, 7133 post_params=form_params, 7134 files=local_var_files, 7135 response_type='BrandResources', 7136 auth_settings=auth_settings, 7137 callback=params.get('callback'), 7138 _return_http_data_only=params.get('_return_http_data_only'), 7139 _preload_content=params.get('_preload_content', True), 7140 _request_timeout=params.get('_request_timeout'), 7141 collection_formats=collection_formats)
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)
7143 def update_consumer_disclosure(self, account_id, lang_code, **kwargs): 7144 """ 7145 Update Consumer Disclosure. 7146 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. 7147 This method makes a synchronous HTTP request by default. To make an 7148 asynchronous HTTP request, please define a `callback` function 7149 to be invoked when receiving the response. 7150 >>> def callback_function(response): 7151 >>> pprint(response) 7152 >>> 7153 >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function) 7154 7155 :param callback function: The callback function 7156 for asynchronous request. (optional) 7157 :param str account_id: The external account number (int) or account ID Guid. (required) 7158 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 7159 :param str include_metadata: 7160 :param ConsumerDisclosure consumer_disclosure: 7161 :return: ConsumerDisclosure 7162 If the method is called asynchronously, 7163 returns the request thread. 7164 """ 7165 kwargs['_return_http_data_only'] = True 7166 if kwargs.get('callback'): 7167 return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7168 else: 7169 (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 7170 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), 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)
7172 def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 7173 """ 7174 Update Consumer Disclosure. 7175 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. 7176 This method makes a synchronous HTTP request by default. To make an 7177 asynchronous HTTP request, please define a `callback` function 7178 to be invoked when receiving the response. 7179 >>> def callback_function(response): 7180 >>> pprint(response) 7181 >>> 7182 >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 7183 7184 :param callback function: The callback function 7185 for asynchronous request. (optional) 7186 :param str account_id: The external account number (int) or account ID Guid. (required) 7187 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 7188 :param str include_metadata: 7189 :param ConsumerDisclosure consumer_disclosure: 7190 :return: ConsumerDisclosure 7191 If the method is called asynchronously, 7192 returns the request thread. 7193 """ 7194 7195 all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure'] 7196 all_params.append('callback') 7197 all_params.append('_return_http_data_only') 7198 all_params.append('_preload_content') 7199 all_params.append('_request_timeout') 7200 7201 params = locals() 7202 for key, val in iteritems(params['kwargs']): 7203 if key not in all_params: 7204 raise TypeError( 7205 "Got an unexpected keyword argument '%s'" 7206 " to method update_consumer_disclosure" % key 7207 ) 7208 params[key] = val 7209 del params['kwargs'] 7210 # verify the required parameter 'account_id' is set 7211 if ('account_id' not in params) or (params['account_id'] is None): 7212 raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`") 7213 # verify the required parameter 'lang_code' is set 7214 if ('lang_code' not in params) or (params['lang_code'] is None): 7215 raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`") 7216 7217 7218 collection_formats = {} 7219 7220 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 7221 path_params = {} 7222 if 'account_id' in params: 7223 path_params['accountId'] = params['account_id'] 7224 if 'lang_code' in params: 7225 path_params['langCode'] = params['lang_code'] 7226 7227 query_params = {} 7228 if 'include_metadata' in params: 7229 query_params['include_metadata'] = params['include_metadata'] 7230 7231 header_params = {} 7232 7233 form_params = [] 7234 local_var_files = {} 7235 7236 body_params = None 7237 if 'consumer_disclosure' in params: 7238 body_params = params['consumer_disclosure'] 7239 # HTTP header `Accept` 7240 header_params['Accept'] = self.api_client.\ 7241 select_header_accept(['application/json']) 7242 7243 # Authentication setting 7244 auth_settings = [] 7245 7246 return self.api_client.call_api(resource_path, 'PUT', 7247 path_params, 7248 query_params, 7249 header_params, 7250 body=body_params, 7251 post_params=form_params, 7252 files=local_var_files, 7253 response_type='ConsumerDisclosure', 7254 auth_settings=auth_settings, 7255 callback=params.get('callback'), 7256 _return_http_data_only=params.get('_return_http_data_only'), 7257 _preload_content=params.get('_preload_content', True), 7258 _request_timeout=params.get('_request_timeout'), 7259 collection_formats=collection_formats)
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), 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)
7261 def update_custom_field(self, account_id, custom_field_id, **kwargs): 7262 """ 7263 Updates an existing account custom field. 7264 This method updates an existing account custom field. 7265 This method makes a synchronous HTTP request by default. To make an 7266 asynchronous HTTP request, please define a `callback` function 7267 to be invoked when receiving the response. 7268 >>> def callback_function(response): 7269 >>> pprint(response) 7270 >>> 7271 >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function) 7272 7273 :param callback function: The callback function 7274 for asynchronous request. (optional) 7275 :param str account_id: The external account number (int) or account ID Guid. (required) 7276 :param str custom_field_id: (required) 7277 :param str apply_to_templates: 7278 :param CustomField custom_field: 7279 :return: CustomFields 7280 If the method is called asynchronously, 7281 returns the request thread. 7282 """ 7283 kwargs['_return_http_data_only'] = True 7284 if kwargs.get('callback'): 7285 return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7286 else: 7287 (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 7288 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)
7290 def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 7291 """ 7292 Updates an existing account custom field. 7293 This method updates an existing account custom field. 7294 This method makes a synchronous HTTP request by default. To make an 7295 asynchronous HTTP request, please define a `callback` function 7296 to be invoked when receiving the response. 7297 >>> def callback_function(response): 7298 >>> pprint(response) 7299 >>> 7300 >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 7301 7302 :param callback function: The callback function 7303 for asynchronous request. (optional) 7304 :param str account_id: The external account number (int) or account ID Guid. (required) 7305 :param str custom_field_id: (required) 7306 :param str apply_to_templates: 7307 :param CustomField custom_field: 7308 :return: CustomFields 7309 If the method is called asynchronously, 7310 returns the request thread. 7311 """ 7312 7313 all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field'] 7314 all_params.append('callback') 7315 all_params.append('_return_http_data_only') 7316 all_params.append('_preload_content') 7317 all_params.append('_request_timeout') 7318 7319 params = locals() 7320 for key, val in iteritems(params['kwargs']): 7321 if key not in all_params: 7322 raise TypeError( 7323 "Got an unexpected keyword argument '%s'" 7324 " to method update_custom_field" % key 7325 ) 7326 params[key] = val 7327 del params['kwargs'] 7328 # verify the required parameter 'account_id' is set 7329 if ('account_id' not in params) or (params['account_id'] is None): 7330 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`") 7331 # verify the required parameter 'custom_field_id' is set 7332 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 7333 raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`") 7334 7335 7336 collection_formats = {} 7337 7338 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 7339 path_params = {} 7340 if 'account_id' in params: 7341 path_params['accountId'] = params['account_id'] 7342 if 'custom_field_id' in params: 7343 path_params['customFieldId'] = params['custom_field_id'] 7344 7345 query_params = {} 7346 if 'apply_to_templates' in params: 7347 query_params['apply_to_templates'] = params['apply_to_templates'] 7348 7349 header_params = {} 7350 7351 form_params = [] 7352 local_var_files = {} 7353 7354 body_params = None 7355 if 'custom_field' in params: 7356 body_params = params['custom_field'] 7357 # HTTP header `Accept` 7358 header_params['Accept'] = self.api_client.\ 7359 select_header_accept(['application/json']) 7360 7361 # Authentication setting 7362 auth_settings = [] 7363 7364 return self.api_client.call_api(resource_path, 'PUT', 7365 path_params, 7366 query_params, 7367 header_params, 7368 body=body_params, 7369 post_params=form_params, 7370 files=local_var_files, 7371 response_type='CustomFields', 7372 auth_settings=auth_settings, 7373 callback=params.get('callback'), 7374 _return_http_data_only=params.get('_return_http_data_only'), 7375 _preload_content=params.get('_preload_content', True), 7376 _request_timeout=params.get('_request_timeout'), 7377 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)
7379 def update_e_note_configuration(self, account_id, **kwargs): 7380 """ 7381 Updates configuration information for the eNote eOriginal integration. 7382 7383 This method makes a synchronous HTTP request by default. To make an 7384 asynchronous HTTP request, please define a `callback` function 7385 to be invoked when receiving the response. 7386 >>> def callback_function(response): 7387 >>> pprint(response) 7388 >>> 7389 >>> thread = api.update_e_note_configuration(account_id, callback=callback_function) 7390 7391 :param callback function: The callback function 7392 for asynchronous request. (optional) 7393 :param str account_id: The external account number (int) or account ID Guid. (required) 7394 :param ENoteConfiguration e_note_configuration: 7395 :return: ENoteConfiguration 7396 If the method is called asynchronously, 7397 returns the request thread. 7398 """ 7399 kwargs['_return_http_data_only'] = True 7400 if kwargs.get('callback'): 7401 return self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7402 else: 7403 (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs) 7404 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)
7406 def update_e_note_configuration_with_http_info(self, account_id, **kwargs): 7407 """ 7408 Updates configuration information for the eNote eOriginal integration. 7409 7410 This method makes a synchronous HTTP request by default. To make an 7411 asynchronous HTTP request, please define a `callback` function 7412 to be invoked when receiving the response. 7413 >>> def callback_function(response): 7414 >>> pprint(response) 7415 >>> 7416 >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function) 7417 7418 :param callback function: The callback function 7419 for asynchronous request. (optional) 7420 :param str account_id: The external account number (int) or account ID Guid. (required) 7421 :param ENoteConfiguration e_note_configuration: 7422 :return: ENoteConfiguration 7423 If the method is called asynchronously, 7424 returns the request thread. 7425 """ 7426 7427 all_params = ['account_id', 'e_note_configuration'] 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_e_note_configuration" % 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_e_note_configuration`") 7445 7446 7447 collection_formats = {} 7448 7449 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 7450 path_params = {} 7451 if 'account_id' in params: 7452 path_params['accountId'] = params['account_id'] 7453 7454 query_params = {} 7455 7456 header_params = {} 7457 7458 form_params = [] 7459 local_var_files = {} 7460 7461 body_params = None 7462 if 'e_note_configuration' in params: 7463 body_params = params['e_note_configuration'] 7464 # HTTP header `Accept` 7465 header_params['Accept'] = self.api_client.\ 7466 select_header_accept(['application/json']) 7467 7468 # Authentication setting 7469 auth_settings = [] 7470 7471 return self.api_client.call_api(resource_path, 'PUT', 7472 path_params, 7473 query_params, 7474 header_params, 7475 body=body_params, 7476 post_params=form_params, 7477 files=local_var_files, 7478 response_type='ENoteConfiguration', 7479 auth_settings=auth_settings, 7480 callback=params.get('callback'), 7481 _return_http_data_only=params.get('_return_http_data_only'), 7482 _preload_content=params.get('_preload_content', True), 7483 _request_timeout=params.get('_request_timeout'), 7484 collection_formats=collection_formats)
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)
7486 def update_envelope_purge_configuration(self, account_id, **kwargs): 7487 """ 7488 Updates envelope purge configuration. 7489 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). 7490 This method makes a synchronous HTTP request by default. To make an 7491 asynchronous HTTP request, please define a `callback` function 7492 to be invoked when receiving the response. 7493 >>> def callback_function(response): 7494 >>> pprint(response) 7495 >>> 7496 >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function) 7497 7498 :param callback function: The callback function 7499 for asynchronous request. (optional) 7500 :param str account_id: The external account number (int) or account ID Guid. (required) 7501 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7502 :return: EnvelopePurgeConfiguration 7503 If the method is called asynchronously, 7504 returns the request thread. 7505 """ 7506 kwargs['_return_http_data_only'] = True 7507 if kwargs.get('callback'): 7508 return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7509 else: 7510 (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 7511 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)
7513 def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 7514 """ 7515 Updates envelope purge configuration. 7516 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). 7517 This method makes a synchronous HTTP request by default. To make an 7518 asynchronous HTTP request, please define a `callback` function 7519 to be invoked when receiving the response. 7520 >>> def callback_function(response): 7521 >>> pprint(response) 7522 >>> 7523 >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 7524 7525 :param callback function: The callback function 7526 for asynchronous request. (optional) 7527 :param str account_id: The external account number (int) or account ID Guid. (required) 7528 :param EnvelopePurgeConfiguration envelope_purge_configuration: 7529 :return: EnvelopePurgeConfiguration 7530 If the method is called asynchronously, 7531 returns the request thread. 7532 """ 7533 7534 all_params = ['account_id', 'envelope_purge_configuration'] 7535 all_params.append('callback') 7536 all_params.append('_return_http_data_only') 7537 all_params.append('_preload_content') 7538 all_params.append('_request_timeout') 7539 7540 params = locals() 7541 for key, val in iteritems(params['kwargs']): 7542 if key not in all_params: 7543 raise TypeError( 7544 "Got an unexpected keyword argument '%s'" 7545 " to method update_envelope_purge_configuration" % key 7546 ) 7547 params[key] = val 7548 del params['kwargs'] 7549 # verify the required parameter 'account_id' is set 7550 if ('account_id' not in params) or (params['account_id'] is None): 7551 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`") 7552 7553 7554 collection_formats = {} 7555 7556 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 7557 path_params = {} 7558 if 'account_id' in params: 7559 path_params['accountId'] = params['account_id'] 7560 7561 query_params = {} 7562 7563 header_params = {} 7564 7565 form_params = [] 7566 local_var_files = {} 7567 7568 body_params = None 7569 if 'envelope_purge_configuration' in params: 7570 body_params = params['envelope_purge_configuration'] 7571 # HTTP header `Accept` 7572 header_params['Accept'] = self.api_client.\ 7573 select_header_accept(['application/json']) 7574 7575 # Authentication setting 7576 auth_settings = [] 7577 7578 return self.api_client.call_api(resource_path, 'PUT', 7579 path_params, 7580 query_params, 7581 header_params, 7582 body=body_params, 7583 post_params=form_params, 7584 files=local_var_files, 7585 response_type='EnvelopePurgeConfiguration', 7586 auth_settings=auth_settings, 7587 callback=params.get('callback'), 7588 _return_http_data_only=params.get('_return_http_data_only'), 7589 _preload_content=params.get('_preload_content', True), 7590 _request_timeout=params.get('_request_timeout'), 7591 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)
7593 def update_favorite_template(self, account_id, **kwargs): 7594 """ 7595 Favorites a template 7596 7597 This method makes a synchronous HTTP request by default. To make an 7598 asynchronous HTTP request, please define a `callback` function 7599 to be invoked when receiving the response. 7600 >>> def callback_function(response): 7601 >>> pprint(response) 7602 >>> 7603 >>> thread = api.update_favorite_template(account_id, callback=callback_function) 7604 7605 :param callback function: The callback function 7606 for asynchronous request. (optional) 7607 :param str account_id: The external account number (int) or account ID Guid. (required) 7608 :param FavoriteTemplatesInfo favorite_templates_info: 7609 :return: FavoriteTemplatesInfo 7610 If the method is called asynchronously, 7611 returns the request thread. 7612 """ 7613 kwargs['_return_http_data_only'] = True 7614 if kwargs.get('callback'): 7615 return self.update_favorite_template_with_http_info(account_id, **kwargs) 7616 else: 7617 (data) = self.update_favorite_template_with_http_info(account_id, **kwargs) 7618 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)
7620 def update_favorite_template_with_http_info(self, account_id, **kwargs): 7621 """ 7622 Favorites a template 7623 7624 This method makes a synchronous HTTP request by default. To make an 7625 asynchronous HTTP request, please define a `callback` function 7626 to be invoked when receiving the response. 7627 >>> def callback_function(response): 7628 >>> pprint(response) 7629 >>> 7630 >>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function) 7631 7632 :param callback function: The callback function 7633 for asynchronous request. (optional) 7634 :param str account_id: The external account number (int) or account ID Guid. (required) 7635 :param FavoriteTemplatesInfo favorite_templates_info: 7636 :return: FavoriteTemplatesInfo 7637 If the method is called asynchronously, 7638 returns the request thread. 7639 """ 7640 7641 all_params = ['account_id', 'favorite_templates_info'] 7642 all_params.append('callback') 7643 all_params.append('_return_http_data_only') 7644 all_params.append('_preload_content') 7645 all_params.append('_request_timeout') 7646 7647 params = locals() 7648 for key, val in iteritems(params['kwargs']): 7649 if key not in all_params: 7650 raise TypeError( 7651 "Got an unexpected keyword argument '%s'" 7652 " to method update_favorite_template" % key 7653 ) 7654 params[key] = val 7655 del params['kwargs'] 7656 # verify the required parameter 'account_id' is set 7657 if ('account_id' not in params) or (params['account_id'] is None): 7658 raise ValueError("Missing the required parameter `account_id` when calling `update_favorite_template`") 7659 7660 7661 collection_formats = {} 7662 7663 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 7664 path_params = {} 7665 if 'account_id' in params: 7666 path_params['accountId'] = params['account_id'] 7667 7668 query_params = {} 7669 7670 header_params = {} 7671 7672 form_params = [] 7673 local_var_files = {} 7674 7675 body_params = None 7676 if 'favorite_templates_info' in params: 7677 body_params = params['favorite_templates_info'] 7678 # HTTP header `Accept` 7679 header_params['Accept'] = self.api_client.\ 7680 select_header_accept(['application/json']) 7681 7682 # Authentication setting 7683 auth_settings = [] 7684 7685 return self.api_client.call_api(resource_path, 'PUT', 7686 path_params, 7687 query_params, 7688 header_params, 7689 body=body_params, 7690 post_params=form_params, 7691 files=local_var_files, 7692 response_type='FavoriteTemplatesInfo', 7693 auth_settings=auth_settings, 7694 callback=params.get('callback'), 7695 _return_http_data_only=params.get('_return_http_data_only'), 7696 _preload_content=params.get('_preload_content', True), 7697 _request_timeout=params.get('_request_timeout'), 7698 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)
7700 def update_notification_defaults(self, account_id, **kwargs): 7701 """ 7702 Updates default user level settings for a specified account 7703 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7704 This method makes a synchronous HTTP request by default. To make an 7705 asynchronous HTTP request, please define a `callback` function 7706 to be invoked when receiving the response. 7707 >>> def callback_function(response): 7708 >>> pprint(response) 7709 >>> 7710 >>> thread = api.update_notification_defaults(account_id, callback=callback_function) 7711 7712 :param callback function: The callback function 7713 for asynchronous request. (optional) 7714 :param str account_id: The external account number (int) or account ID Guid. (required) 7715 :param NotificationDefaults notification_defaults: 7716 :return: NotificationDefaults 7717 If the method is called asynchronously, 7718 returns the request thread. 7719 """ 7720 kwargs['_return_http_data_only'] = True 7721 if kwargs.get('callback'): 7722 return self.update_notification_defaults_with_http_info(account_id, **kwargs) 7723 else: 7724 (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs) 7725 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)
7727 def update_notification_defaults_with_http_info(self, account_id, **kwargs): 7728 """ 7729 Updates default user level settings for a specified account 7730 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 7731 This method makes a synchronous HTTP request by default. To make an 7732 asynchronous HTTP request, please define a `callback` function 7733 to be invoked when receiving the response. 7734 >>> def callback_function(response): 7735 >>> pprint(response) 7736 >>> 7737 >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function) 7738 7739 :param callback function: The callback function 7740 for asynchronous request. (optional) 7741 :param str account_id: The external account number (int) or account ID Guid. (required) 7742 :param NotificationDefaults notification_defaults: 7743 :return: NotificationDefaults 7744 If the method is called asynchronously, 7745 returns the request thread. 7746 """ 7747 7748 all_params = ['account_id', 'notification_defaults'] 7749 all_params.append('callback') 7750 all_params.append('_return_http_data_only') 7751 all_params.append('_preload_content') 7752 all_params.append('_request_timeout') 7753 7754 params = locals() 7755 for key, val in iteritems(params['kwargs']): 7756 if key not in all_params: 7757 raise TypeError( 7758 "Got an unexpected keyword argument '%s'" 7759 " to method update_notification_defaults" % key 7760 ) 7761 params[key] = val 7762 del params['kwargs'] 7763 # verify the required parameter 'account_id' is set 7764 if ('account_id' not in params) or (params['account_id'] is None): 7765 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`") 7766 7767 7768 collection_formats = {} 7769 7770 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 7771 path_params = {} 7772 if 'account_id' in params: 7773 path_params['accountId'] = params['account_id'] 7774 7775 query_params = {} 7776 7777 header_params = {} 7778 7779 form_params = [] 7780 local_var_files = {} 7781 7782 body_params = None 7783 if 'notification_defaults' in params: 7784 body_params = params['notification_defaults'] 7785 # HTTP header `Accept` 7786 header_params['Accept'] = self.api_client.\ 7787 select_header_accept(['application/json']) 7788 7789 # Authentication setting 7790 auth_settings = [] 7791 7792 return self.api_client.call_api(resource_path, 'PUT', 7793 path_params, 7794 query_params, 7795 header_params, 7796 body=body_params, 7797 post_params=form_params, 7798 files=local_var_files, 7799 response_type='NotificationDefaults', 7800 auth_settings=auth_settings, 7801 callback=params.get('callback'), 7802 _return_http_data_only=params.get('_return_http_data_only'), 7803 _preload_content=params.get('_preload_content', True), 7804 _request_timeout=params.get('_request_timeout'), 7805 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)
7807 def update_password_rules(self, account_id, **kwargs): 7808 """ 7809 Update the password rules 7810 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7811 This method makes a synchronous HTTP request by default. To make an 7812 asynchronous HTTP request, please define a `callback` function 7813 to be invoked when receiving the response. 7814 >>> def callback_function(response): 7815 >>> pprint(response) 7816 >>> 7817 >>> thread = api.update_password_rules(account_id, callback=callback_function) 7818 7819 :param callback function: The callback function 7820 for asynchronous request. (optional) 7821 :param str account_id: The external account number (int) or account ID Guid. (required) 7822 :param AccountPasswordRules account_password_rules: 7823 :return: AccountPasswordRules 7824 If the method is called asynchronously, 7825 returns the request thread. 7826 """ 7827 kwargs['_return_http_data_only'] = True 7828 if kwargs.get('callback'): 7829 return self.update_password_rules_with_http_info(account_id, **kwargs) 7830 else: 7831 (data) = self.update_password_rules_with_http_info(account_id, **kwargs) 7832 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)
7834 def update_password_rules_with_http_info(self, account_id, **kwargs): 7835 """ 7836 Update the password rules 7837 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7838 This method makes a synchronous HTTP request by default. To make an 7839 asynchronous HTTP request, please define a `callback` function 7840 to be invoked when receiving the response. 7841 >>> def callback_function(response): 7842 >>> pprint(response) 7843 >>> 7844 >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function) 7845 7846 :param callback function: The callback function 7847 for asynchronous request. (optional) 7848 :param str account_id: The external account number (int) or account ID Guid. (required) 7849 :param AccountPasswordRules account_password_rules: 7850 :return: AccountPasswordRules 7851 If the method is called asynchronously, 7852 returns the request thread. 7853 """ 7854 7855 all_params = ['account_id', 'account_password_rules'] 7856 all_params.append('callback') 7857 all_params.append('_return_http_data_only') 7858 all_params.append('_preload_content') 7859 all_params.append('_request_timeout') 7860 7861 params = locals() 7862 for key, val in iteritems(params['kwargs']): 7863 if key not in all_params: 7864 raise TypeError( 7865 "Got an unexpected keyword argument '%s'" 7866 " to method update_password_rules" % key 7867 ) 7868 params[key] = val 7869 del params['kwargs'] 7870 # verify the required parameter 'account_id' is set 7871 if ('account_id' not in params) or (params['account_id'] is None): 7872 raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`") 7873 7874 7875 collection_formats = {} 7876 7877 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 7878 path_params = {} 7879 if 'account_id' in params: 7880 path_params['accountId'] = params['account_id'] 7881 7882 query_params = {} 7883 7884 header_params = {} 7885 7886 form_params = [] 7887 local_var_files = {} 7888 7889 body_params = None 7890 if 'account_password_rules' in params: 7891 body_params = params['account_password_rules'] 7892 # HTTP header `Accept` 7893 header_params['Accept'] = self.api_client.\ 7894 select_header_accept(['application/json']) 7895 7896 # Authentication setting 7897 auth_settings = [] 7898 7899 return self.api_client.call_api(resource_path, 'PUT', 7900 path_params, 7901 query_params, 7902 header_params, 7903 body=body_params, 7904 post_params=form_params, 7905 files=local_var_files, 7906 response_type='AccountPasswordRules', 7907 auth_settings=auth_settings, 7908 callback=params.get('callback'), 7909 _return_http_data_only=params.get('_return_http_data_only'), 7910 _preload_content=params.get('_preload_content', True), 7911 _request_timeout=params.get('_request_timeout'), 7912 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)
7914 def update_permission_profile(self, account_id, permission_profile_id, **kwargs): 7915 """ 7916 Updates a permission profile within the specified account. 7917 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7918 This method makes a synchronous HTTP request by default. To make an 7919 asynchronous HTTP request, please define a `callback` function 7920 to be invoked when receiving the response. 7921 >>> def callback_function(response): 7922 >>> pprint(response) 7923 >>> 7924 >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function) 7925 7926 :param callback function: The callback function 7927 for asynchronous request. (optional) 7928 :param str account_id: The external account number (int) or account ID Guid. (required) 7929 :param str permission_profile_id: (required) 7930 :param str include: 7931 :param PermissionProfile permission_profile: 7932 :return: PermissionProfile 7933 If the method is called asynchronously, 7934 returns the request thread. 7935 """ 7936 kwargs['_return_http_data_only'] = True 7937 if kwargs.get('callback'): 7938 return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7939 else: 7940 (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7941 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)
7943 def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 7944 """ 7945 Updates a permission profile within the specified account. 7946 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7947 This method makes a synchronous HTTP request by default. To make an 7948 asynchronous HTTP request, please define a `callback` function 7949 to be invoked when receiving the response. 7950 >>> def callback_function(response): 7951 >>> pprint(response) 7952 >>> 7953 >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 7954 7955 :param callback function: The callback function 7956 for asynchronous request. (optional) 7957 :param str account_id: The external account number (int) or account ID Guid. (required) 7958 :param str permission_profile_id: (required) 7959 :param str include: 7960 :param PermissionProfile permission_profile: 7961 :return: PermissionProfile 7962 If the method is called asynchronously, 7963 returns the request thread. 7964 """ 7965 7966 all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile'] 7967 all_params.append('callback') 7968 all_params.append('_return_http_data_only') 7969 all_params.append('_preload_content') 7970 all_params.append('_request_timeout') 7971 7972 params = locals() 7973 for key, val in iteritems(params['kwargs']): 7974 if key not in all_params: 7975 raise TypeError( 7976 "Got an unexpected keyword argument '%s'" 7977 " to method update_permission_profile" % key 7978 ) 7979 params[key] = val 7980 del params['kwargs'] 7981 # verify the required parameter 'account_id' is set 7982 if ('account_id' not in params) or (params['account_id'] is None): 7983 raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`") 7984 # verify the required parameter 'permission_profile_id' is set 7985 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 7986 raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`") 7987 7988 7989 collection_formats = {} 7990 7991 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 7992 path_params = {} 7993 if 'account_id' in params: 7994 path_params['accountId'] = params['account_id'] 7995 if 'permission_profile_id' in params: 7996 path_params['permissionProfileId'] = params['permission_profile_id'] 7997 7998 query_params = {} 7999 if 'include' in params: 8000 query_params['include'] = params['include'] 8001 8002 header_params = {} 8003 8004 form_params = [] 8005 local_var_files = {} 8006 8007 body_params = None 8008 if 'permission_profile' in params: 8009 body_params = params['permission_profile'] 8010 # HTTP header `Accept` 8011 header_params['Accept'] = self.api_client.\ 8012 select_header_accept(['application/json']) 8013 8014 # Authentication setting 8015 auth_settings = [] 8016 8017 return self.api_client.call_api(resource_path, 'PUT', 8018 path_params, 8019 query_params, 8020 header_params, 8021 body=body_params, 8022 post_params=form_params, 8023 files=local_var_files, 8024 response_type='PermissionProfile', 8025 auth_settings=auth_settings, 8026 callback=params.get('callback'), 8027 _return_http_data_only=params.get('_return_http_data_only'), 8028 _preload_content=params.get('_preload_content', True), 8029 _request_timeout=params.get('_request_timeout'), 8030 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)
8032 def update_settings(self, account_id, **kwargs): 8033 """ 8034 Updates the account settings for an account. 8035 Updates the account settings for the specified account. 8036 This method makes a synchronous HTTP request by default. To make an 8037 asynchronous HTTP request, please define a `callback` function 8038 to be invoked when receiving the response. 8039 >>> def callback_function(response): 8040 >>> pprint(response) 8041 >>> 8042 >>> thread = api.update_settings(account_id, callback=callback_function) 8043 8044 :param callback function: The callback function 8045 for asynchronous request. (optional) 8046 :param str account_id: The external account number (int) or account ID Guid. (required) 8047 :param AccountSettingsInformation account_settings_information: 8048 :return: None 8049 If the method is called asynchronously, 8050 returns the request thread. 8051 """ 8052 kwargs['_return_http_data_only'] = True 8053 if kwargs.get('callback'): 8054 return self.update_settings_with_http_info(account_id, **kwargs) 8055 else: 8056 (data) = self.update_settings_with_http_info(account_id, **kwargs) 8057 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)
8059 def update_settings_with_http_info(self, account_id, **kwargs): 8060 """ 8061 Updates the account settings for an account. 8062 Updates the account settings for the specified account. 8063 This method makes a synchronous HTTP request by default. To make an 8064 asynchronous HTTP request, please define a `callback` function 8065 to be invoked when receiving the response. 8066 >>> def callback_function(response): 8067 >>> pprint(response) 8068 >>> 8069 >>> thread = api.update_settings_with_http_info(account_id, callback=callback_function) 8070 8071 :param callback function: The callback function 8072 for asynchronous request. (optional) 8073 :param str account_id: The external account number (int) or account ID Guid. (required) 8074 :param AccountSettingsInformation account_settings_information: 8075 :return: None 8076 If the method is called asynchronously, 8077 returns the request thread. 8078 """ 8079 8080 all_params = ['account_id', 'account_settings_information'] 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_settings" % 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_settings`") 8098 8099 8100 collection_formats = {} 8101 8102 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 8103 path_params = {} 8104 if 'account_id' in params: 8105 path_params['accountId'] = params['account_id'] 8106 8107 query_params = {} 8108 8109 header_params = {} 8110 8111 form_params = [] 8112 local_var_files = {} 8113 8114 body_params = None 8115 if 'account_settings_information' in params: 8116 body_params = params['account_settings_information'] 8117 # HTTP header `Accept` 8118 header_params['Accept'] = self.api_client.\ 8119 select_header_accept(['application/json']) 8120 8121 # Authentication setting 8122 auth_settings = [] 8123 8124 return self.api_client.call_api(resource_path, 'PUT', 8125 path_params, 8126 query_params, 8127 header_params, 8128 body=body_params, 8129 post_params=form_params, 8130 files=local_var_files, 8131 response_type=None, 8132 auth_settings=auth_settings, 8133 callback=params.get('callback'), 8134 _return_http_data_only=params.get('_return_http_data_only'), 8135 _preload_content=params.get('_preload_content', True), 8136 _request_timeout=params.get('_request_timeout'), 8137 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)
8377 def update_watermark(self, account_id, **kwargs): 8378 """ 8379 Update watermark information. 8380 8381 This method makes a synchronous HTTP request by default. To make an 8382 asynchronous HTTP request, please define a `callback` function 8383 to be invoked when receiving the response. 8384 >>> def callback_function(response): 8385 >>> pprint(response) 8386 >>> 8387 >>> thread = api.update_watermark(account_id, callback=callback_function) 8388 8389 :param callback function: The callback function 8390 for asynchronous request. (optional) 8391 :param str account_id: The external account number (int) or account ID Guid. (required) 8392 :param Watermark watermark: 8393 :return: Watermark 8394 If the method is called asynchronously, 8395 returns the request thread. 8396 """ 8397 kwargs['_return_http_data_only'] = True 8398 if kwargs.get('callback'): 8399 return self.update_watermark_with_http_info(account_id, **kwargs) 8400 else: 8401 (data) = self.update_watermark_with_http_info(account_id, **kwargs) 8402 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)
8404 def update_watermark_with_http_info(self, account_id, **kwargs): 8405 """ 8406 Update watermark information. 8407 8408 This method makes a synchronous HTTP request by default. To make an 8409 asynchronous HTTP request, please define a `callback` function 8410 to be invoked when receiving the response. 8411 >>> def callback_function(response): 8412 >>> pprint(response) 8413 >>> 8414 >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function) 8415 8416 :param callback function: The callback function 8417 for asynchronous request. (optional) 8418 :param str account_id: The external account number (int) or account ID Guid. (required) 8419 :param Watermark watermark: 8420 :return: Watermark 8421 If the method is called asynchronously, 8422 returns the request thread. 8423 """ 8424 8425 all_params = ['account_id', 'watermark'] 8426 all_params.append('callback') 8427 all_params.append('_return_http_data_only') 8428 all_params.append('_preload_content') 8429 all_params.append('_request_timeout') 8430 8431 params = locals() 8432 for key, val in iteritems(params['kwargs']): 8433 if key not in all_params: 8434 raise TypeError( 8435 "Got an unexpected keyword argument '%s'" 8436 " to method update_watermark" % key 8437 ) 8438 params[key] = val 8439 del params['kwargs'] 8440 # verify the required parameter 'account_id' is set 8441 if ('account_id' not in params) or (params['account_id'] is None): 8442 raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`") 8443 8444 8445 collection_formats = {} 8446 8447 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 8448 path_params = {} 8449 if 'account_id' in params: 8450 path_params['accountId'] = params['account_id'] 8451 8452 query_params = {} 8453 8454 header_params = {} 8455 8456 form_params = [] 8457 local_var_files = {} 8458 8459 body_params = None 8460 if 'watermark' in params: 8461 body_params = params['watermark'] 8462 # HTTP header `Accept` 8463 header_params['Accept'] = self.api_client.\ 8464 select_header_accept(['application/json']) 8465 8466 # Authentication setting 8467 auth_settings = [] 8468 8469 return self.api_client.call_api(resource_path, 'PUT', 8470 path_params, 8471 query_params, 8472 header_params, 8473 body=body_params, 8474 post_params=form_params, 8475 files=local_var_files, 8476 response_type='Watermark', 8477 auth_settings=auth_settings, 8478 callback=params.get('callback'), 8479 _return_http_data_only=params.get('_return_http_data_only'), 8480 _preload_content=params.get('_preload_content', True), 8481 _request_timeout=params.get('_request_timeout'), 8482 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.