docusign_esign.apis.signing_groups_api

   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 SigningGroupsApi(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_list(self, account_id, **kwargs):
  44        """
  45        Creates a signing group. 
  46        Creates one or more signing groups.   Multiple signing groups can be created in one call. Only users with account administrator privileges can create signing groups.   An account can have a maximum of 50 signing groups. Each signing group can have a maximum of 50 group members.   Signing groups can be used by any account user.
  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_list(account_id, callback=callback_function)
  54
  55        :param callback function: The callback function
  56            for asynchronous request. (optional)
  57        :param str account_id: The external account number (int) or account ID Guid. (required)
  58        :param SigningGroupInformation signing_group_information:
  59        :return: SigningGroupInformation
  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_list_with_http_info(account_id, **kwargs)
  66        else:
  67            (data) = self.create_list_with_http_info(account_id, **kwargs)
  68            return data
  69
  70    def create_list_with_http_info(self, account_id, **kwargs):
  71        """
  72        Creates a signing group. 
  73        Creates one or more signing groups.   Multiple signing groups can be created in one call. Only users with account administrator privileges can create signing groups.   An account can have a maximum of 50 signing groups. Each signing group can have a maximum of 50 group members.   Signing groups can be used by any account user.
  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_list_with_http_info(account_id, callback=callback_function)
  81
  82        :param callback function: The callback function
  83            for asynchronous request. (optional)
  84        :param str account_id: The external account number (int) or account ID Guid. (required)
  85        :param SigningGroupInformation signing_group_information:
  86        :return: SigningGroupInformation
  87                 If the method is called asynchronously,
  88                 returns the request thread.
  89        """
  90
  91        all_params = ['account_id', 'signing_group_information']
  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_list" % key
 103                )
 104            params[key] = val
 105        del params['kwargs']
 106        # verify the required parameter 'account_id' is set
 107        if ('account_id' not in params) or (params['account_id'] is None):
 108            raise ValueError("Missing the required parameter `account_id` when calling `create_list`")
 109
 110
 111        collection_formats = {}
 112
 113        resource_path = '/v2.1/accounts/{accountId}/signing_groups'.replace('{format}', 'json')
 114        path_params = {}
 115        if 'account_id' in params:
 116            path_params['accountId'] = params['account_id']
 117
 118        query_params = {}
 119
 120        header_params = {}
 121
 122        form_params = []
 123        local_var_files = {}
 124
 125        body_params = None
 126        if 'signing_group_information' in params:
 127            body_params = params['signing_group_information']
 128        # HTTP header `Accept`
 129        header_params['Accept'] = self.api_client.\
 130            select_header_accept(['application/json'])
 131
 132        # Authentication setting
 133        auth_settings = []
 134
 135        return self.api_client.call_api(resource_path, 'POST',
 136                                        path_params,
 137                                        query_params,
 138                                        header_params,
 139                                        body=body_params,
 140                                        post_params=form_params,
 141                                        files=local_var_files,
 142                                        response_type='SigningGroupInformation',
 143                                        auth_settings=auth_settings,
 144                                        callback=params.get('callback'),
 145                                        _return_http_data_only=params.get('_return_http_data_only'),
 146                                        _preload_content=params.get('_preload_content', True),
 147                                        _request_timeout=params.get('_request_timeout'),
 148                                        collection_formats=collection_formats)
 149
 150    def delete_list(self, account_id, **kwargs):
 151        """
 152        Deletes one or more signing groups.
 153        Deletes one or more signing groups in the specified account.
 154        This method makes a synchronous HTTP request by default. To make an
 155        asynchronous HTTP request, please define a `callback` function
 156        to be invoked when receiving the response.
 157        >>> def callback_function(response):
 158        >>>     pprint(response)
 159        >>>
 160        >>> thread = api.delete_list(account_id, callback=callback_function)
 161
 162        :param callback function: The callback function
 163            for asynchronous request. (optional)
 164        :param str account_id: The external account number (int) or account ID Guid. (required)
 165        :param SigningGroupInformation signing_group_information:
 166        :return: SigningGroupInformation
 167                 If the method is called asynchronously,
 168                 returns the request thread.
 169        """
 170        kwargs['_return_http_data_only'] = True
 171        if kwargs.get('callback'):
 172            return self.delete_list_with_http_info(account_id, **kwargs)
 173        else:
 174            (data) = self.delete_list_with_http_info(account_id, **kwargs)
 175            return data
 176
 177    def delete_list_with_http_info(self, account_id, **kwargs):
 178        """
 179        Deletes one or more signing groups.
 180        Deletes one or more signing groups in the specified account.
 181        This method makes a synchronous HTTP request by default. To make an
 182        asynchronous HTTP request, please define a `callback` function
 183        to be invoked when receiving the response.
 184        >>> def callback_function(response):
 185        >>>     pprint(response)
 186        >>>
 187        >>> thread = api.delete_list_with_http_info(account_id, callback=callback_function)
 188
 189        :param callback function: The callback function
 190            for asynchronous request. (optional)
 191        :param str account_id: The external account number (int) or account ID Guid. (required)
 192        :param SigningGroupInformation signing_group_information:
 193        :return: SigningGroupInformation
 194                 If the method is called asynchronously,
 195                 returns the request thread.
 196        """
 197
 198        all_params = ['account_id', 'signing_group_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 delete_list" % 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 `delete_list`")
 216
 217
 218        collection_formats = {}
 219
 220        resource_path = '/v2.1/accounts/{accountId}/signing_groups'.replace('{format}', 'json')
 221        path_params = {}
 222        if 'account_id' in params:
 223            path_params['accountId'] = params['account_id']
 224
 225        query_params = {}
 226
 227        header_params = {}
 228
 229        form_params = []
 230        local_var_files = {}
 231
 232        body_params = None
 233        if 'signing_group_information' in params:
 234            body_params = params['signing_group_information']
 235        # HTTP header `Accept`
 236        header_params['Accept'] = self.api_client.\
 237            select_header_accept(['application/json'])
 238
 239        # Authentication setting
 240        auth_settings = []
 241
 242        return self.api_client.call_api(resource_path, 'DELETE',
 243                                        path_params,
 244                                        query_params,
 245                                        header_params,
 246                                        body=body_params,
 247                                        post_params=form_params,
 248                                        files=local_var_files,
 249                                        response_type='SigningGroupInformation',
 250                                        auth_settings=auth_settings,
 251                                        callback=params.get('callback'),
 252                                        _return_http_data_only=params.get('_return_http_data_only'),
 253                                        _preload_content=params.get('_preload_content', True),
 254                                        _request_timeout=params.get('_request_timeout'),
 255                                        collection_formats=collection_formats)
 256
 257    def delete_users(self, account_id, signing_group_id, **kwargs):
 258        """
 259        Deletes  one or more members from a signing group.
 260        Deletes  one or more members from the specified signing group. 
 261        This method makes a synchronous HTTP request by default. To make an
 262        asynchronous HTTP request, please define a `callback` function
 263        to be invoked when receiving the response.
 264        >>> def callback_function(response):
 265        >>>     pprint(response)
 266        >>>
 267        >>> thread = api.delete_users(account_id, signing_group_id, callback=callback_function)
 268
 269        :param callback function: The callback function
 270            for asynchronous request. (optional)
 271        :param str account_id: The external account number (int) or account ID Guid. (required)
 272        :param str signing_group_id: (required)
 273        :param SigningGroupUsers signing_group_users:
 274        :return: SigningGroupUsers
 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.delete_users_with_http_info(account_id, signing_group_id, **kwargs)
 281        else:
 282            (data) = self.delete_users_with_http_info(account_id, signing_group_id, **kwargs)
 283            return data
 284
 285    def delete_users_with_http_info(self, account_id, signing_group_id, **kwargs):
 286        """
 287        Deletes  one or more members from a signing group.
 288        Deletes  one or more members from the specified signing group. 
 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.delete_users_with_http_info(account_id, signing_group_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 str signing_group_id: (required)
 301        :param SigningGroupUsers signing_group_users:
 302        :return: SigningGroupUsers
 303                 If the method is called asynchronously,
 304                 returns the request thread.
 305        """
 306
 307        all_params = ['account_id', 'signing_group_id', 'signing_group_users']
 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 delete_users" % 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 `delete_users`")
 325        # verify the required parameter 'signing_group_id' is set
 326        if ('signing_group_id' not in params) or (params['signing_group_id'] is None):
 327            raise ValueError("Missing the required parameter `signing_group_id` when calling `delete_users`")
 328
 329
 330        collection_formats = {}
 331
 332        resource_path = '/v2.1/accounts/{accountId}/signing_groups/{signingGroupId}/users'.replace('{format}', 'json')
 333        path_params = {}
 334        if 'account_id' in params:
 335            path_params['accountId'] = params['account_id']
 336        if 'signing_group_id' in params:
 337            path_params['signingGroupId'] = params['signing_group_id']
 338
 339        query_params = {}
 340
 341        header_params = {}
 342
 343        form_params = []
 344        local_var_files = {}
 345
 346        body_params = None
 347        if 'signing_group_users' in params:
 348            body_params = params['signing_group_users']
 349        # HTTP header `Accept`
 350        header_params['Accept'] = self.api_client.\
 351            select_header_accept(['application/json'])
 352
 353        # Authentication setting
 354        auth_settings = []
 355
 356        return self.api_client.call_api(resource_path, 'DELETE',
 357                                        path_params,
 358                                        query_params,
 359                                        header_params,
 360                                        body=body_params,
 361                                        post_params=form_params,
 362                                        files=local_var_files,
 363                                        response_type='SigningGroupUsers',
 364                                        auth_settings=auth_settings,
 365                                        callback=params.get('callback'),
 366                                        _return_http_data_only=params.get('_return_http_data_only'),
 367                                        _preload_content=params.get('_preload_content', True),
 368                                        _request_timeout=params.get('_request_timeout'),
 369                                        collection_formats=collection_formats)
 370
 371    def get(self, account_id, signing_group_id, **kwargs):
 372        """
 373        Gets information about a signing group. 
 374        Retrieves information, including group member information, for the specified signing group. 
 375        This method makes a synchronous HTTP request by default. To make an
 376        asynchronous HTTP request, please define a `callback` function
 377        to be invoked when receiving the response.
 378        >>> def callback_function(response):
 379        >>>     pprint(response)
 380        >>>
 381        >>> thread = api.get(account_id, signing_group_id, callback=callback_function)
 382
 383        :param callback function: The callback function
 384            for asynchronous request. (optional)
 385        :param str account_id: The external account number (int) or account ID Guid. (required)
 386        :param str signing_group_id: (required)
 387        :return: SigningGroup
 388                 If the method is called asynchronously,
 389                 returns the request thread.
 390        """
 391        kwargs['_return_http_data_only'] = True
 392        if kwargs.get('callback'):
 393            return self.get_with_http_info(account_id, signing_group_id, **kwargs)
 394        else:
 395            (data) = self.get_with_http_info(account_id, signing_group_id, **kwargs)
 396            return data
 397
 398    def get_with_http_info(self, account_id, signing_group_id, **kwargs):
 399        """
 400        Gets information about a signing group. 
 401        Retrieves information, including group member information, for the specified signing group. 
 402        This method makes a synchronous HTTP request by default. To make an
 403        asynchronous HTTP request, please define a `callback` function
 404        to be invoked when receiving the response.
 405        >>> def callback_function(response):
 406        >>>     pprint(response)
 407        >>>
 408        >>> thread = api.get_with_http_info(account_id, signing_group_id, callback=callback_function)
 409
 410        :param callback function: The callback function
 411            for asynchronous request. (optional)
 412        :param str account_id: The external account number (int) or account ID Guid. (required)
 413        :param str signing_group_id: (required)
 414        :return: SigningGroup
 415                 If the method is called asynchronously,
 416                 returns the request thread.
 417        """
 418
 419        all_params = ['account_id', 'signing_group_id']
 420        all_params.append('callback')
 421        all_params.append('_return_http_data_only')
 422        all_params.append('_preload_content')
 423        all_params.append('_request_timeout')
 424
 425        params = locals()
 426        for key, val in iteritems(params['kwargs']):
 427            if key not in all_params:
 428                raise TypeError(
 429                    "Got an unexpected keyword argument '%s'"
 430                    " to method get" % key
 431                )
 432            params[key] = val
 433        del params['kwargs']
 434        # verify the required parameter 'account_id' is set
 435        if ('account_id' not in params) or (params['account_id'] is None):
 436            raise ValueError("Missing the required parameter `account_id` when calling `get`")
 437        # verify the required parameter 'signing_group_id' is set
 438        if ('signing_group_id' not in params) or (params['signing_group_id'] is None):
 439            raise ValueError("Missing the required parameter `signing_group_id` when calling `get`")
 440
 441
 442        collection_formats = {}
 443
 444        resource_path = '/v2.1/accounts/{accountId}/signing_groups/{signingGroupId}'.replace('{format}', 'json')
 445        path_params = {}
 446        if 'account_id' in params:
 447            path_params['accountId'] = params['account_id']
 448        if 'signing_group_id' in params:
 449            path_params['signingGroupId'] = params['signing_group_id']
 450
 451        query_params = {}
 452
 453        header_params = {}
 454
 455        form_params = []
 456        local_var_files = {}
 457
 458        body_params = None
 459        # HTTP header `Accept`
 460        header_params['Accept'] = self.api_client.\
 461            select_header_accept(['application/json'])
 462
 463        # Authentication setting
 464        auth_settings = []
 465
 466        return self.api_client.call_api(resource_path, 'GET',
 467                                        path_params,
 468                                        query_params,
 469                                        header_params,
 470                                        body=body_params,
 471                                        post_params=form_params,
 472                                        files=local_var_files,
 473                                        response_type='SigningGroup',
 474                                        auth_settings=auth_settings,
 475                                        callback=params.get('callback'),
 476                                        _return_http_data_only=params.get('_return_http_data_only'),
 477                                        _preload_content=params.get('_preload_content', True),
 478                                        _request_timeout=params.get('_request_timeout'),
 479                                        collection_formats=collection_formats)
 480
 481    def list(self, account_id, **kwargs):
 482        """
 483        Gets a list of the Signing Groups in an account.
 484        Retrieves a list of all signing groups in the specified account.
 485        This method makes a synchronous HTTP request by default. To make an
 486        asynchronous HTTP request, please define a `callback` function
 487        to be invoked when receiving the response.
 488        >>> def callback_function(response):
 489        >>>     pprint(response)
 490        >>>
 491        >>> thread = api.list(account_id, callback=callback_function)
 492
 493        :param callback function: The callback function
 494            for asynchronous request. (optional)
 495        :param str account_id: The external account number (int) or account ID Guid. (required)
 496        :param str group_type:
 497        :param str include_users: When set to **true**, the response includes the signing group members. 
 498        :return: SigningGroupInformation
 499                 If the method is called asynchronously,
 500                 returns the request thread.
 501        """
 502        kwargs['_return_http_data_only'] = True
 503        if kwargs.get('callback'):
 504            return self.list_with_http_info(account_id, **kwargs)
 505        else:
 506            (data) = self.list_with_http_info(account_id, **kwargs)
 507            return data
 508
 509    def list_with_http_info(self, account_id, **kwargs):
 510        """
 511        Gets a list of the Signing Groups in an account.
 512        Retrieves a list of all signing groups in the specified account.
 513        This method makes a synchronous HTTP request by default. To make an
 514        asynchronous HTTP request, please define a `callback` function
 515        to be invoked when receiving the response.
 516        >>> def callback_function(response):
 517        >>>     pprint(response)
 518        >>>
 519        >>> thread = api.list_with_http_info(account_id, callback=callback_function)
 520
 521        :param callback function: The callback function
 522            for asynchronous request. (optional)
 523        :param str account_id: The external account number (int) or account ID Guid. (required)
 524        :param str group_type:
 525        :param str include_users: When set to **true**, the response includes the signing group members. 
 526        :return: SigningGroupInformation
 527                 If the method is called asynchronously,
 528                 returns the request thread.
 529        """
 530
 531        all_params = ['account_id', 'group_type', 'include_users']
 532        all_params.append('callback')
 533        all_params.append('_return_http_data_only')
 534        all_params.append('_preload_content')
 535        all_params.append('_request_timeout')
 536
 537        params = locals()
 538        for key, val in iteritems(params['kwargs']):
 539            if key not in all_params:
 540                raise TypeError(
 541                    "Got an unexpected keyword argument '%s'"
 542                    " to method list" % key
 543                )
 544            params[key] = val
 545        del params['kwargs']
 546        # verify the required parameter 'account_id' is set
 547        if ('account_id' not in params) or (params['account_id'] is None):
 548            raise ValueError("Missing the required parameter `account_id` when calling `list`")
 549
 550
 551        collection_formats = {}
 552
 553        resource_path = '/v2.1/accounts/{accountId}/signing_groups'.replace('{format}', 'json')
 554        path_params = {}
 555        if 'account_id' in params:
 556            path_params['accountId'] = params['account_id']
 557
 558        query_params = {}
 559        if 'group_type' in params:
 560            query_params['group_type'] = params['group_type']
 561        if 'include_users' in params:
 562            query_params['include_users'] = params['include_users']
 563
 564        header_params = {}
 565
 566        form_params = []
 567        local_var_files = {}
 568
 569        body_params = None
 570        # HTTP header `Accept`
 571        header_params['Accept'] = self.api_client.\
 572            select_header_accept(['application/json'])
 573
 574        # Authentication setting
 575        auth_settings = []
 576
 577        return self.api_client.call_api(resource_path, 'GET',
 578                                        path_params,
 579                                        query_params,
 580                                        header_params,
 581                                        body=body_params,
 582                                        post_params=form_params,
 583                                        files=local_var_files,
 584                                        response_type='SigningGroupInformation',
 585                                        auth_settings=auth_settings,
 586                                        callback=params.get('callback'),
 587                                        _return_http_data_only=params.get('_return_http_data_only'),
 588                                        _preload_content=params.get('_preload_content', True),
 589                                        _request_timeout=params.get('_request_timeout'),
 590                                        collection_formats=collection_formats)
 591
 592    def list_users(self, account_id, signing_group_id, **kwargs):
 593        """
 594        Gets a list of members in a Signing Group.
 595        Retrieves the list of members in the specified Signing Group.
 596        This method makes a synchronous HTTP request by default. To make an
 597        asynchronous HTTP request, please define a `callback` function
 598        to be invoked when receiving the response.
 599        >>> def callback_function(response):
 600        >>>     pprint(response)
 601        >>>
 602        >>> thread = api.list_users(account_id, signing_group_id, callback=callback_function)
 603
 604        :param callback function: The callback function
 605            for asynchronous request. (optional)
 606        :param str account_id: The external account number (int) or account ID Guid. (required)
 607        :param str signing_group_id: (required)
 608        :return: SigningGroupUsers
 609                 If the method is called asynchronously,
 610                 returns the request thread.
 611        """
 612        kwargs['_return_http_data_only'] = True
 613        if kwargs.get('callback'):
 614            return self.list_users_with_http_info(account_id, signing_group_id, **kwargs)
 615        else:
 616            (data) = self.list_users_with_http_info(account_id, signing_group_id, **kwargs)
 617            return data
 618
 619    def list_users_with_http_info(self, account_id, signing_group_id, **kwargs):
 620        """
 621        Gets a list of members in a Signing Group.
 622        Retrieves the list of members in the specified Signing Group.
 623        This method makes a synchronous HTTP request by default. To make an
 624        asynchronous HTTP request, please define a `callback` function
 625        to be invoked when receiving the response.
 626        >>> def callback_function(response):
 627        >>>     pprint(response)
 628        >>>
 629        >>> thread = api.list_users_with_http_info(account_id, signing_group_id, callback=callback_function)
 630
 631        :param callback function: The callback function
 632            for asynchronous request. (optional)
 633        :param str account_id: The external account number (int) or account ID Guid. (required)
 634        :param str signing_group_id: (required)
 635        :return: SigningGroupUsers
 636                 If the method is called asynchronously,
 637                 returns the request thread.
 638        """
 639
 640        all_params = ['account_id', 'signing_group_id']
 641        all_params.append('callback')
 642        all_params.append('_return_http_data_only')
 643        all_params.append('_preload_content')
 644        all_params.append('_request_timeout')
 645
 646        params = locals()
 647        for key, val in iteritems(params['kwargs']):
 648            if key not in all_params:
 649                raise TypeError(
 650                    "Got an unexpected keyword argument '%s'"
 651                    " to method list_users" % key
 652                )
 653            params[key] = val
 654        del params['kwargs']
 655        # verify the required parameter 'account_id' is set
 656        if ('account_id' not in params) or (params['account_id'] is None):
 657            raise ValueError("Missing the required parameter `account_id` when calling `list_users`")
 658        # verify the required parameter 'signing_group_id' is set
 659        if ('signing_group_id' not in params) or (params['signing_group_id'] is None):
 660            raise ValueError("Missing the required parameter `signing_group_id` when calling `list_users`")
 661
 662
 663        collection_formats = {}
 664
 665        resource_path = '/v2.1/accounts/{accountId}/signing_groups/{signingGroupId}/users'.replace('{format}', 'json')
 666        path_params = {}
 667        if 'account_id' in params:
 668            path_params['accountId'] = params['account_id']
 669        if 'signing_group_id' in params:
 670            path_params['signingGroupId'] = params['signing_group_id']
 671
 672        query_params = {}
 673
 674        header_params = {}
 675
 676        form_params = []
 677        local_var_files = {}
 678
 679        body_params = None
 680        # HTTP header `Accept`
 681        header_params['Accept'] = self.api_client.\
 682            select_header_accept(['application/json'])
 683
 684        # Authentication setting
 685        auth_settings = []
 686
 687        return self.api_client.call_api(resource_path, 'GET',
 688                                        path_params,
 689                                        query_params,
 690                                        header_params,
 691                                        body=body_params,
 692                                        post_params=form_params,
 693                                        files=local_var_files,
 694                                        response_type='SigningGroupUsers',
 695                                        auth_settings=auth_settings,
 696                                        callback=params.get('callback'),
 697                                        _return_http_data_only=params.get('_return_http_data_only'),
 698                                        _preload_content=params.get('_preload_content', True),
 699                                        _request_timeout=params.get('_request_timeout'),
 700                                        collection_formats=collection_formats)
 701
 702    def update(self, account_id, signing_group_id, **kwargs):
 703        """
 704        Updates a signing group. 
 705        Updates signing group name and member information. You can also add new members to the signing group. A signing group can have a maximum of 50 members. 
 706        This method makes a synchronous HTTP request by default. To make an
 707        asynchronous HTTP request, please define a `callback` function
 708        to be invoked when receiving the response.
 709        >>> def callback_function(response):
 710        >>>     pprint(response)
 711        >>>
 712        >>> thread = api.update(account_id, signing_group_id, callback=callback_function)
 713
 714        :param callback function: The callback function
 715            for asynchronous request. (optional)
 716        :param str account_id: The external account number (int) or account ID Guid. (required)
 717        :param str signing_group_id: (required)
 718        :param SigningGroup signing_group:
 719        :return: SigningGroup
 720                 If the method is called asynchronously,
 721                 returns the request thread.
 722        """
 723        kwargs['_return_http_data_only'] = True
 724        if kwargs.get('callback'):
 725            return self.update_with_http_info(account_id, signing_group_id, **kwargs)
 726        else:
 727            (data) = self.update_with_http_info(account_id, signing_group_id, **kwargs)
 728            return data
 729
 730    def update_with_http_info(self, account_id, signing_group_id, **kwargs):
 731        """
 732        Updates a signing group. 
 733        Updates signing group name and member information. You can also add new members to the signing group. A signing group can have a maximum of 50 members. 
 734        This method makes a synchronous HTTP request by default. To make an
 735        asynchronous HTTP request, please define a `callback` function
 736        to be invoked when receiving the response.
 737        >>> def callback_function(response):
 738        >>>     pprint(response)
 739        >>>
 740        >>> thread = api.update_with_http_info(account_id, signing_group_id, callback=callback_function)
 741
 742        :param callback function: The callback function
 743            for asynchronous request. (optional)
 744        :param str account_id: The external account number (int) or account ID Guid. (required)
 745        :param str signing_group_id: (required)
 746        :param SigningGroup signing_group:
 747        :return: SigningGroup
 748                 If the method is called asynchronously,
 749                 returns the request thread.
 750        """
 751
 752        all_params = ['account_id', 'signing_group_id', 'signing_group']
 753        all_params.append('callback')
 754        all_params.append('_return_http_data_only')
 755        all_params.append('_preload_content')
 756        all_params.append('_request_timeout')
 757
 758        params = locals()
 759        for key, val in iteritems(params['kwargs']):
 760            if key not in all_params:
 761                raise TypeError(
 762                    "Got an unexpected keyword argument '%s'"
 763                    " to method update" % key
 764                )
 765            params[key] = val
 766        del params['kwargs']
 767        # verify the required parameter 'account_id' is set
 768        if ('account_id' not in params) or (params['account_id'] is None):
 769            raise ValueError("Missing the required parameter `account_id` when calling `update`")
 770        # verify the required parameter 'signing_group_id' is set
 771        if ('signing_group_id' not in params) or (params['signing_group_id'] is None):
 772            raise ValueError("Missing the required parameter `signing_group_id` when calling `update`")
 773
 774
 775        collection_formats = {}
 776
 777        resource_path = '/v2.1/accounts/{accountId}/signing_groups/{signingGroupId}'.replace('{format}', 'json')
 778        path_params = {}
 779        if 'account_id' in params:
 780            path_params['accountId'] = params['account_id']
 781        if 'signing_group_id' in params:
 782            path_params['signingGroupId'] = params['signing_group_id']
 783
 784        query_params = {}
 785
 786        header_params = {}
 787
 788        form_params = []
 789        local_var_files = {}
 790
 791        body_params = None
 792        if 'signing_group' in params:
 793            body_params = params['signing_group']
 794        # HTTP header `Accept`
 795        header_params['Accept'] = self.api_client.\
 796            select_header_accept(['application/json'])
 797
 798        # Authentication setting
 799        auth_settings = []
 800
 801        return self.api_client.call_api(resource_path, 'PUT',
 802                                        path_params,
 803                                        query_params,
 804                                        header_params,
 805                                        body=body_params,
 806                                        post_params=form_params,
 807                                        files=local_var_files,
 808                                        response_type='SigningGroup',
 809                                        auth_settings=auth_settings,
 810                                        callback=params.get('callback'),
 811                                        _return_http_data_only=params.get('_return_http_data_only'),
 812                                        _preload_content=params.get('_preload_content', True),
 813                                        _request_timeout=params.get('_request_timeout'),
 814                                        collection_formats=collection_formats)
 815
 816    def update_list(self, account_id, **kwargs):
 817        """
 818        Updates signing group names.
 819        Updates the name of one or more existing signing groups. 
 820        This method makes a synchronous HTTP request by default. To make an
 821        asynchronous HTTP request, please define a `callback` function
 822        to be invoked when receiving the response.
 823        >>> def callback_function(response):
 824        >>>     pprint(response)
 825        >>>
 826        >>> thread = api.update_list(account_id, callback=callback_function)
 827
 828        :param callback function: The callback function
 829            for asynchronous request. (optional)
 830        :param str account_id: The external account number (int) or account ID Guid. (required)
 831        :param SigningGroupInformation signing_group_information:
 832        :return: SigningGroupInformation
 833                 If the method is called asynchronously,
 834                 returns the request thread.
 835        """
 836        kwargs['_return_http_data_only'] = True
 837        if kwargs.get('callback'):
 838            return self.update_list_with_http_info(account_id, **kwargs)
 839        else:
 840            (data) = self.update_list_with_http_info(account_id, **kwargs)
 841            return data
 842
 843    def update_list_with_http_info(self, account_id, **kwargs):
 844        """
 845        Updates signing group names.
 846        Updates the name of one or more existing signing groups. 
 847        This method makes a synchronous HTTP request by default. To make an
 848        asynchronous HTTP request, please define a `callback` function
 849        to be invoked when receiving the response.
 850        >>> def callback_function(response):
 851        >>>     pprint(response)
 852        >>>
 853        >>> thread = api.update_list_with_http_info(account_id, callback=callback_function)
 854
 855        :param callback function: The callback function
 856            for asynchronous request. (optional)
 857        :param str account_id: The external account number (int) or account ID Guid. (required)
 858        :param SigningGroupInformation signing_group_information:
 859        :return: SigningGroupInformation
 860                 If the method is called asynchronously,
 861                 returns the request thread.
 862        """
 863
 864        all_params = ['account_id', 'signing_group_information']
 865        all_params.append('callback')
 866        all_params.append('_return_http_data_only')
 867        all_params.append('_preload_content')
 868        all_params.append('_request_timeout')
 869
 870        params = locals()
 871        for key, val in iteritems(params['kwargs']):
 872            if key not in all_params:
 873                raise TypeError(
 874                    "Got an unexpected keyword argument '%s'"
 875                    " to method update_list" % key
 876                )
 877            params[key] = val
 878        del params['kwargs']
 879        # verify the required parameter 'account_id' is set
 880        if ('account_id' not in params) or (params['account_id'] is None):
 881            raise ValueError("Missing the required parameter `account_id` when calling `update_list`")
 882
 883
 884        collection_formats = {}
 885
 886        resource_path = '/v2.1/accounts/{accountId}/signing_groups'.replace('{format}', 'json')
 887        path_params = {}
 888        if 'account_id' in params:
 889            path_params['accountId'] = params['account_id']
 890
 891        query_params = {}
 892
 893        header_params = {}
 894
 895        form_params = []
 896        local_var_files = {}
 897
 898        body_params = None
 899        if 'signing_group_information' in params:
 900            body_params = params['signing_group_information']
 901        # HTTP header `Accept`
 902        header_params['Accept'] = self.api_client.\
 903            select_header_accept(['application/json'])
 904
 905        # Authentication setting
 906        auth_settings = []
 907
 908        return self.api_client.call_api(resource_path, 'PUT',
 909                                        path_params,
 910                                        query_params,
 911                                        header_params,
 912                                        body=body_params,
 913                                        post_params=form_params,
 914                                        files=local_var_files,
 915                                        response_type='SigningGroupInformation',
 916                                        auth_settings=auth_settings,
 917                                        callback=params.get('callback'),
 918                                        _return_http_data_only=params.get('_return_http_data_only'),
 919                                        _preload_content=params.get('_preload_content', True),
 920                                        _request_timeout=params.get('_request_timeout'),
 921                                        collection_formats=collection_formats)
 922
 923    def update_users(self, account_id, signing_group_id, **kwargs):
 924        """
 925        Adds members to a signing group. 
 926        Adds one or more new members to a signing group. A signing group can have a maximum of 50 members. 
 927        This method makes a synchronous HTTP request by default. To make an
 928        asynchronous HTTP request, please define a `callback` function
 929        to be invoked when receiving the response.
 930        >>> def callback_function(response):
 931        >>>     pprint(response)
 932        >>>
 933        >>> thread = api.update_users(account_id, signing_group_id, callback=callback_function)
 934
 935        :param callback function: The callback function
 936            for asynchronous request. (optional)
 937        :param str account_id: The external account number (int) or account ID Guid. (required)
 938        :param str signing_group_id: (required)
 939        :param SigningGroupUsers signing_group_users:
 940        :return: SigningGroupUsers
 941                 If the method is called asynchronously,
 942                 returns the request thread.
 943        """
 944        kwargs['_return_http_data_only'] = True
 945        if kwargs.get('callback'):
 946            return self.update_users_with_http_info(account_id, signing_group_id, **kwargs)
 947        else:
 948            (data) = self.update_users_with_http_info(account_id, signing_group_id, **kwargs)
 949            return data
 950
 951    def update_users_with_http_info(self, account_id, signing_group_id, **kwargs):
 952        """
 953        Adds members to a signing group. 
 954        Adds one or more new members to a signing group. A signing group can have a maximum of 50 members. 
 955        This method makes a synchronous HTTP request by default. To make an
 956        asynchronous HTTP request, please define a `callback` function
 957        to be invoked when receiving the response.
 958        >>> def callback_function(response):
 959        >>>     pprint(response)
 960        >>>
 961        >>> thread = api.update_users_with_http_info(account_id, signing_group_id, callback=callback_function)
 962
 963        :param callback function: The callback function
 964            for asynchronous request. (optional)
 965        :param str account_id: The external account number (int) or account ID Guid. (required)
 966        :param str signing_group_id: (required)
 967        :param SigningGroupUsers signing_group_users:
 968        :return: SigningGroupUsers
 969                 If the method is called asynchronously,
 970                 returns the request thread.
 971        """
 972
 973        all_params = ['account_id', 'signing_group_id', 'signing_group_users']
 974        all_params.append('callback')
 975        all_params.append('_return_http_data_only')
 976        all_params.append('_preload_content')
 977        all_params.append('_request_timeout')
 978
 979        params = locals()
 980        for key, val in iteritems(params['kwargs']):
 981            if key not in all_params:
 982                raise TypeError(
 983                    "Got an unexpected keyword argument '%s'"
 984                    " to method update_users" % key
 985                )
 986            params[key] = val
 987        del params['kwargs']
 988        # verify the required parameter 'account_id' is set
 989        if ('account_id' not in params) or (params['account_id'] is None):
 990            raise ValueError("Missing the required parameter `account_id` when calling `update_users`")
 991        # verify the required parameter 'signing_group_id' is set
 992        if ('signing_group_id' not in params) or (params['signing_group_id'] is None):
 993            raise ValueError("Missing the required parameter `signing_group_id` when calling `update_users`")
 994
 995
 996        collection_formats = {}
 997
 998        resource_path = '/v2.1/accounts/{accountId}/signing_groups/{signingGroupId}/users'.replace('{format}', 'json')
 999        path_params = {}
1000        if 'account_id' in params:
1001            path_params['accountId'] = params['account_id']
1002        if 'signing_group_id' in params:
1003            path_params['signingGroupId'] = params['signing_group_id']
1004
1005        query_params = {}
1006
1007        header_params = {}
1008
1009        form_params = []
1010        local_var_files = {}
1011
1012        body_params = None
1013        if 'signing_group_users' in params:
1014            body_params = params['signing_group_users']
1015        # HTTP header `Accept`
1016        header_params['Accept'] = self.api_client.\
1017            select_header_accept(['application/json'])
1018
1019        # Authentication setting
1020        auth_settings = []
1021
1022        return self.api_client.call_api(resource_path, 'PUT',
1023                                        path_params,
1024                                        query_params,
1025                                        header_params,
1026                                        body=body_params,
1027                                        post_params=form_params,
1028                                        files=local_var_files,
1029                                        response_type='SigningGroupUsers',
1030                                        auth_settings=auth_settings,
1031                                        callback=params.get('callback'),
1032                                        _return_http_data_only=params.get('_return_http_data_only'),
1033                                        _preload_content=params.get('_preload_content', True),
1034                                        _request_timeout=params.get('_request_timeout'),
1035                                        collection_formats=collection_formats)