docusign_esign.apis.notary_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 NotaryApi(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_notary(self, **kwargs):
  44        """
  45        Add a notary to the system
  46        Registers the current user as a notary.
  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_notary(callback=callback_function)
  54
  55        :param callback function: The callback function
  56            for asynchronous request. (optional)
  57        :param Notary notary:
  58        :return: Notary
  59                 If the method is called asynchronously,
  60                 returns the request thread.
  61        """
  62        kwargs['_return_http_data_only'] = True
  63        if kwargs.get('callback'):
  64            return self.create_notary_with_http_info(**kwargs)
  65        else:
  66            (data) = self.create_notary_with_http_info(**kwargs)
  67            return data
  68
  69    def create_notary_with_http_info(self, **kwargs):
  70        """
  71        Add a notary to the system
  72        Registers the current user as a notary.
  73        This method makes a synchronous HTTP request by default. To make an
  74        asynchronous HTTP request, please define a `callback` function
  75        to be invoked when receiving the response.
  76        >>> def callback_function(response):
  77        >>>     pprint(response)
  78        >>>
  79        >>> thread = api.create_notary_with_http_info(callback=callback_function)
  80
  81        :param callback function: The callback function
  82            for asynchronous request. (optional)
  83        :param Notary notary:
  84        :return: Notary
  85                 If the method is called asynchronously,
  86                 returns the request thread.
  87        """
  88
  89        all_params = ['notary']
  90        all_params.append('callback')
  91        all_params.append('_return_http_data_only')
  92        all_params.append('_preload_content')
  93        all_params.append('_request_timeout')
  94
  95        params = locals()
  96        for key, val in iteritems(params['kwargs']):
  97            if key not in all_params:
  98                raise TypeError(
  99                    "Got an unexpected keyword argument '%s'"
 100                    " to method create_notary" % key
 101                )
 102            params[key] = val
 103        del params['kwargs']
 104
 105
 106        collection_formats = {}
 107
 108        resource_path = '/v2.1/current_user/notary'.replace('{format}', 'json')
 109        path_params = {}
 110
 111        query_params = {}
 112
 113        header_params = {}
 114
 115        form_params = []
 116        local_var_files = {}
 117
 118        body_params = None
 119        if 'notary' in params:
 120            body_params = params['notary']
 121        # HTTP header `Accept`
 122        header_params['Accept'] = self.api_client.\
 123            select_header_accept(['application/json'])
 124
 125        # Authentication setting
 126        auth_settings = []
 127
 128        return self.api_client.call_api(resource_path, 'POST',
 129                                        path_params,
 130                                        query_params,
 131                                        header_params,
 132                                        body=body_params,
 133                                        post_params=form_params,
 134                                        files=local_var_files,
 135                                        response_type='Notary',
 136                                        auth_settings=auth_settings,
 137                                        callback=params.get('callback'),
 138                                        _return_http_data_only=params.get('_return_http_data_only'),
 139                                        _preload_content=params.get('_preload_content', True),
 140                                        _request_timeout=params.get('_request_timeout'),
 141                                        collection_formats=collection_formats)
 142
 143    def create_notary_jurisdictions(self, **kwargs):
 144        """
 145        Add a notary jurisdiction to the system
 146        Creates a jurisdiction object.
 147        This method makes a synchronous HTTP request by default. To make an
 148        asynchronous HTTP request, please define a `callback` function
 149        to be invoked when receiving the response.
 150        >>> def callback_function(response):
 151        >>>     pprint(response)
 152        >>>
 153        >>> thread = api.create_notary_jurisdictions(callback=callback_function)
 154
 155        :param callback function: The callback function
 156            for asynchronous request. (optional)
 157        :param NotaryJurisdiction notary_jurisdiction:
 158        :return: NotaryJurisdiction
 159                 If the method is called asynchronously,
 160                 returns the request thread.
 161        """
 162        kwargs['_return_http_data_only'] = True
 163        if kwargs.get('callback'):
 164            return self.create_notary_jurisdictions_with_http_info(**kwargs)
 165        else:
 166            (data) = self.create_notary_jurisdictions_with_http_info(**kwargs)
 167            return data
 168
 169    def create_notary_jurisdictions_with_http_info(self, **kwargs):
 170        """
 171        Add a notary jurisdiction to the system
 172        Creates a jurisdiction object.
 173        This method makes a synchronous HTTP request by default. To make an
 174        asynchronous HTTP request, please define a `callback` function
 175        to be invoked when receiving the response.
 176        >>> def callback_function(response):
 177        >>>     pprint(response)
 178        >>>
 179        >>> thread = api.create_notary_jurisdictions_with_http_info(callback=callback_function)
 180
 181        :param callback function: The callback function
 182            for asynchronous request. (optional)
 183        :param NotaryJurisdiction notary_jurisdiction:
 184        :return: NotaryJurisdiction
 185                 If the method is called asynchronously,
 186                 returns the request thread.
 187        """
 188
 189        all_params = ['notary_jurisdiction']
 190        all_params.append('callback')
 191        all_params.append('_return_http_data_only')
 192        all_params.append('_preload_content')
 193        all_params.append('_request_timeout')
 194
 195        params = locals()
 196        for key, val in iteritems(params['kwargs']):
 197            if key not in all_params:
 198                raise TypeError(
 199                    "Got an unexpected keyword argument '%s'"
 200                    " to method create_notary_jurisdictions" % key
 201                )
 202            params[key] = val
 203        del params['kwargs']
 204
 205
 206        collection_formats = {}
 207
 208        resource_path = '/v2.1/current_user/notary/jurisdictions'.replace('{format}', 'json')
 209        path_params = {}
 210
 211        query_params = {}
 212
 213        header_params = {}
 214
 215        form_params = []
 216        local_var_files = {}
 217
 218        body_params = None
 219        if 'notary_jurisdiction' in params:
 220            body_params = params['notary_jurisdiction']
 221        # HTTP header `Accept`
 222        header_params['Accept'] = self.api_client.\
 223            select_header_accept(['application/json'])
 224
 225        # Authentication setting
 226        auth_settings = []
 227
 228        return self.api_client.call_api(resource_path, 'POST',
 229                                        path_params,
 230                                        query_params,
 231                                        header_params,
 232                                        body=body_params,
 233                                        post_params=form_params,
 234                                        files=local_var_files,
 235                                        response_type='NotaryJurisdiction',
 236                                        auth_settings=auth_settings,
 237                                        callback=params.get('callback'),
 238                                        _return_http_data_only=params.get('_return_http_data_only'),
 239                                        _preload_content=params.get('_preload_content', True),
 240                                        _request_timeout=params.get('_request_timeout'),
 241                                        collection_formats=collection_formats)
 242
 243    def delete_notary_jurisdiction(self, jurisdiction_id, **kwargs):
 244        """
 245        Delete a notary jurisdiction a specified user.
 246        Deletes the specified jurisdiction.
 247        This method makes a synchronous HTTP request by default. To make an
 248        asynchronous HTTP request, please define a `callback` function
 249        to be invoked when receiving the response.
 250        >>> def callback_function(response):
 251        >>>     pprint(response)
 252        >>>
 253        >>> thread = api.delete_notary_jurisdiction(jurisdiction_id, callback=callback_function)
 254
 255        :param callback function: The callback function
 256            for asynchronous request. (optional)
 257        :param str jurisdiction_id: (required)
 258        :return: None
 259                 If the method is called asynchronously,
 260                 returns the request thread.
 261        """
 262        kwargs['_return_http_data_only'] = True
 263        if kwargs.get('callback'):
 264            return self.delete_notary_jurisdiction_with_http_info(jurisdiction_id, **kwargs)
 265        else:
 266            (data) = self.delete_notary_jurisdiction_with_http_info(jurisdiction_id, **kwargs)
 267            return data
 268
 269    def delete_notary_jurisdiction_with_http_info(self, jurisdiction_id, **kwargs):
 270        """
 271        Delete a notary jurisdiction a specified user.
 272        Deletes the specified jurisdiction.
 273        This method makes a synchronous HTTP request by default. To make an
 274        asynchronous HTTP request, please define a `callback` function
 275        to be invoked when receiving the response.
 276        >>> def callback_function(response):
 277        >>>     pprint(response)
 278        >>>
 279        >>> thread = api.delete_notary_jurisdiction_with_http_info(jurisdiction_id, callback=callback_function)
 280
 281        :param callback function: The callback function
 282            for asynchronous request. (optional)
 283        :param str jurisdiction_id: (required)
 284        :return: None
 285                 If the method is called asynchronously,
 286                 returns the request thread.
 287        """
 288
 289        all_params = ['jurisdiction_id']
 290        all_params.append('callback')
 291        all_params.append('_return_http_data_only')
 292        all_params.append('_preload_content')
 293        all_params.append('_request_timeout')
 294
 295        params = locals()
 296        for key, val in iteritems(params['kwargs']):
 297            if key not in all_params:
 298                raise TypeError(
 299                    "Got an unexpected keyword argument '%s'"
 300                    " to method delete_notary_jurisdiction" % key
 301                )
 302            params[key] = val
 303        del params['kwargs']
 304        # verify the required parameter 'jurisdiction_id' is set
 305        if ('jurisdiction_id' not in params) or (params['jurisdiction_id'] is None):
 306            raise ValueError("Missing the required parameter `jurisdiction_id` when calling `delete_notary_jurisdiction`")
 307
 308
 309        collection_formats = {}
 310
 311        resource_path = '/v2.1/current_user/notary/jurisdictions/{jurisdictionId}'.replace('{format}', 'json')
 312        path_params = {}
 313        if 'jurisdiction_id' in params:
 314            path_params['jurisdictionId'] = params['jurisdiction_id']
 315
 316        query_params = {}
 317
 318        header_params = {}
 319
 320        form_params = []
 321        local_var_files = {}
 322
 323        body_params = None
 324        # HTTP header `Accept`
 325        header_params['Accept'] = self.api_client.\
 326            select_header_accept(['application/json'])
 327
 328        # Authentication setting
 329        auth_settings = []
 330
 331        return self.api_client.call_api(resource_path, 'DELETE',
 332                                        path_params,
 333                                        query_params,
 334                                        header_params,
 335                                        body=body_params,
 336                                        post_params=form_params,
 337                                        files=local_var_files,
 338                                        response_type=None,
 339                                        auth_settings=auth_settings,
 340                                        callback=params.get('callback'),
 341                                        _return_http_data_only=params.get('_return_http_data_only'),
 342                                        _preload_content=params.get('_preload_content', True),
 343                                        _request_timeout=params.get('_request_timeout'),
 344                                        collection_formats=collection_formats)
 345
 346    def get_notary(self, **kwargs):
 347        """
 348        Get notary settings for a user
 349        Gets settings for a notary user. The current user must be a notary.
 350        This method makes a synchronous HTTP request by default. To make an
 351        asynchronous HTTP request, please define a `callback` function
 352        to be invoked when receiving the response.
 353        >>> def callback_function(response):
 354        >>>     pprint(response)
 355        >>>
 356        >>> thread = api.get_notary(callback=callback_function)
 357
 358        :param callback function: The callback function
 359            for asynchronous request. (optional)
 360        :param str include_jurisdictions:
 361        :return: NotaryResult
 362                 If the method is called asynchronously,
 363                 returns the request thread.
 364        """
 365        kwargs['_return_http_data_only'] = True
 366        if kwargs.get('callback'):
 367            return self.get_notary_with_http_info(**kwargs)
 368        else:
 369            (data) = self.get_notary_with_http_info(**kwargs)
 370            return data
 371
 372    def get_notary_with_http_info(self, **kwargs):
 373        """
 374        Get notary settings for a user
 375        Gets settings for a notary user. The current user must be a notary.
 376        This method makes a synchronous HTTP request by default. To make an
 377        asynchronous HTTP request, please define a `callback` function
 378        to be invoked when receiving the response.
 379        >>> def callback_function(response):
 380        >>>     pprint(response)
 381        >>>
 382        >>> thread = api.get_notary_with_http_info(callback=callback_function)
 383
 384        :param callback function: The callback function
 385            for asynchronous request. (optional)
 386        :param str include_jurisdictions:
 387        :return: NotaryResult
 388                 If the method is called asynchronously,
 389                 returns the request thread.
 390        """
 391
 392        all_params = ['include_jurisdictions']
 393        all_params.append('callback')
 394        all_params.append('_return_http_data_only')
 395        all_params.append('_preload_content')
 396        all_params.append('_request_timeout')
 397
 398        params = locals()
 399        for key, val in iteritems(params['kwargs']):
 400            if key not in all_params:
 401                raise TypeError(
 402                    "Got an unexpected keyword argument '%s'"
 403                    " to method get_notary" % key
 404                )
 405            params[key] = val
 406        del params['kwargs']
 407
 408
 409        collection_formats = {}
 410
 411        resource_path = '/v2.1/current_user/notary'.replace('{format}', 'json')
 412        path_params = {}
 413
 414        query_params = {}
 415        if 'include_jurisdictions' in params:
 416            query_params['include_jurisdictions'] = params['include_jurisdictions']
 417
 418        header_params = {}
 419
 420        form_params = []
 421        local_var_files = {}
 422
 423        body_params = None
 424        # HTTP header `Accept`
 425        header_params['Accept'] = self.api_client.\
 426            select_header_accept(['application/json'])
 427
 428        # Authentication setting
 429        auth_settings = []
 430
 431        return self.api_client.call_api(resource_path, 'GET',
 432                                        path_params,
 433                                        query_params,
 434                                        header_params,
 435                                        body=body_params,
 436                                        post_params=form_params,
 437                                        files=local_var_files,
 438                                        response_type='NotaryResult',
 439                                        auth_settings=auth_settings,
 440                                        callback=params.get('callback'),
 441                                        _return_http_data_only=params.get('_return_http_data_only'),
 442                                        _preload_content=params.get('_preload_content', True),
 443                                        _request_timeout=params.get('_request_timeout'),
 444                                        collection_formats=collection_formats)
 445
 446    def get_notary_jurisdiction(self, jurisdiction_id, **kwargs):
 447        """
 448        Get notary a jurisdiction for a user
 449        Gets a jurisdiction object for the current user.  The following restrictions apply:  - The current user must be a notary. - The `jurisdictionId` must be a jurisdiction that the notary is registered for. 
 450        This method makes a synchronous HTTP request by default. To make an
 451        asynchronous HTTP request, please define a `callback` function
 452        to be invoked when receiving the response.
 453        >>> def callback_function(response):
 454        >>>     pprint(response)
 455        >>>
 456        >>> thread = api.get_notary_jurisdiction(jurisdiction_id, callback=callback_function)
 457
 458        :param callback function: The callback function
 459            for asynchronous request. (optional)
 460        :param str jurisdiction_id: (required)
 461        :return: NotaryJurisdiction
 462                 If the method is called asynchronously,
 463                 returns the request thread.
 464        """
 465        kwargs['_return_http_data_only'] = True
 466        if kwargs.get('callback'):
 467            return self.get_notary_jurisdiction_with_http_info(jurisdiction_id, **kwargs)
 468        else:
 469            (data) = self.get_notary_jurisdiction_with_http_info(jurisdiction_id, **kwargs)
 470            return data
 471
 472    def get_notary_jurisdiction_with_http_info(self, jurisdiction_id, **kwargs):
 473        """
 474        Get notary a jurisdiction for a user
 475        Gets a jurisdiction object for the current user.  The following restrictions apply:  - The current user must be a notary. - The `jurisdictionId` must be a jurisdiction that the notary is registered for. 
 476        This method makes a synchronous HTTP request by default. To make an
 477        asynchronous HTTP request, please define a `callback` function
 478        to be invoked when receiving the response.
 479        >>> def callback_function(response):
 480        >>>     pprint(response)
 481        >>>
 482        >>> thread = api.get_notary_jurisdiction_with_http_info(jurisdiction_id, callback=callback_function)
 483
 484        :param callback function: The callback function
 485            for asynchronous request. (optional)
 486        :param str jurisdiction_id: (required)
 487        :return: NotaryJurisdiction
 488                 If the method is called asynchronously,
 489                 returns the request thread.
 490        """
 491
 492        all_params = ['jurisdiction_id']
 493        all_params.append('callback')
 494        all_params.append('_return_http_data_only')
 495        all_params.append('_preload_content')
 496        all_params.append('_request_timeout')
 497
 498        params = locals()
 499        for key, val in iteritems(params['kwargs']):
 500            if key not in all_params:
 501                raise TypeError(
 502                    "Got an unexpected keyword argument '%s'"
 503                    " to method get_notary_jurisdiction" % key
 504                )
 505            params[key] = val
 506        del params['kwargs']
 507        # verify the required parameter 'jurisdiction_id' is set
 508        if ('jurisdiction_id' not in params) or (params['jurisdiction_id'] is None):
 509            raise ValueError("Missing the required parameter `jurisdiction_id` when calling `get_notary_jurisdiction`")
 510
 511
 512        collection_formats = {}
 513
 514        resource_path = '/v2.1/current_user/notary/jurisdictions/{jurisdictionId}'.replace('{format}', 'json')
 515        path_params = {}
 516        if 'jurisdiction_id' in params:
 517            path_params['jurisdictionId'] = params['jurisdiction_id']
 518
 519        query_params = {}
 520
 521        header_params = {}
 522
 523        form_params = []
 524        local_var_files = {}
 525
 526        body_params = None
 527        # HTTP header `Accept`
 528        header_params['Accept'] = self.api_client.\
 529            select_header_accept(['application/json'])
 530
 531        # Authentication setting
 532        auth_settings = []
 533
 534        return self.api_client.call_api(resource_path, 'GET',
 535                                        path_params,
 536                                        query_params,
 537                                        header_params,
 538                                        body=body_params,
 539                                        post_params=form_params,
 540                                        files=local_var_files,
 541                                        response_type='NotaryJurisdiction',
 542                                        auth_settings=auth_settings,
 543                                        callback=params.get('callback'),
 544                                        _return_http_data_only=params.get('_return_http_data_only'),
 545                                        _preload_content=params.get('_preload_content', True),
 546                                        _request_timeout=params.get('_request_timeout'),
 547                                        collection_formats=collection_formats)
 548
 549    def get_notary_jurisdiction_seal(self, jurisdiction_id, **kwargs):
 550        """
 551        Get notary seal for a jurisdiction
 552        
 553        This method makes a synchronous HTTP request by default. To make an
 554        asynchronous HTTP request, please define a `callback` function
 555        to be invoked when receiving the response.
 556        >>> def callback_function(response):
 557        >>>     pprint(response)
 558        >>>
 559        >>> thread = api.get_notary_jurisdiction_seal(jurisdiction_id, callback=callback_function)
 560
 561        :param callback function: The callback function
 562            for asynchronous request. (optional)
 563        :param str jurisdiction_id: (required)
 564        :return: None
 565                 If the method is called asynchronously,
 566                 returns the request thread.
 567        """
 568        kwargs['_return_http_data_only'] = True
 569        if kwargs.get('callback'):
 570            return self.get_notary_jurisdiction_seal_with_http_info(jurisdiction_id, **kwargs)
 571        else:
 572            (data) = self.get_notary_jurisdiction_seal_with_http_info(jurisdiction_id, **kwargs)
 573            return data
 574
 575    def get_notary_jurisdiction_seal_with_http_info(self, jurisdiction_id, **kwargs):
 576        """
 577        Get notary seal for a jurisdiction
 578        
 579        This method makes a synchronous HTTP request by default. To make an
 580        asynchronous HTTP request, please define a `callback` function
 581        to be invoked when receiving the response.
 582        >>> def callback_function(response):
 583        >>>     pprint(response)
 584        >>>
 585        >>> thread = api.get_notary_jurisdiction_seal_with_http_info(jurisdiction_id, callback=callback_function)
 586
 587        :param callback function: The callback function
 588            for asynchronous request. (optional)
 589        :param str jurisdiction_id: (required)
 590        :return: None
 591                 If the method is called asynchronously,
 592                 returns the request thread.
 593        """
 594
 595        all_params = ['jurisdiction_id']
 596        all_params.append('callback')
 597        all_params.append('_return_http_data_only')
 598        all_params.append('_preload_content')
 599        all_params.append('_request_timeout')
 600
 601        params = locals()
 602        for key, val in iteritems(params['kwargs']):
 603            if key not in all_params:
 604                raise TypeError(
 605                    "Got an unexpected keyword argument '%s'"
 606                    " to method get_notary_jurisdiction_seal" % key
 607                )
 608            params[key] = val
 609        del params['kwargs']
 610        # verify the required parameter 'jurisdiction_id' is set
 611        if ('jurisdiction_id' not in params) or (params['jurisdiction_id'] is None):
 612            raise ValueError("Missing the required parameter `jurisdiction_id` when calling `get_notary_jurisdiction_seal`")
 613
 614
 615        collection_formats = {}
 616
 617        resource_path = '/v2.1/current_user/notary/jurisdictions/{jurisdictionId}/seal'.replace('{format}', 'json')
 618        path_params = {}
 619        if 'jurisdiction_id' in params:
 620            path_params['jurisdictionId'] = params['jurisdiction_id']
 621
 622        query_params = {}
 623
 624        header_params = {}
 625
 626        form_params = []
 627        local_var_files = {}
 628
 629        body_params = None
 630        # HTTP header `Accept`
 631        header_params['Accept'] = self.api_client.\
 632            select_header_accept(['application/json'])
 633
 634        # Authentication setting
 635        auth_settings = []
 636
 637        return self.api_client.call_api(resource_path, 'GET',
 638                                        path_params,
 639                                        query_params,
 640                                        header_params,
 641                                        body=body_params,
 642                                        post_params=form_params,
 643                                        files=local_var_files,
 644                                        response_type=None,
 645                                        auth_settings=auth_settings,
 646                                        callback=params.get('callback'),
 647                                        _return_http_data_only=params.get('_return_http_data_only'),
 648                                        _preload_content=params.get('_preload_content', True),
 649                                        _request_timeout=params.get('_request_timeout'),
 650                                        collection_formats=collection_formats)
 651
 652    def get_notary_jurisdictions(self, **kwargs):
 653        """
 654        Get notary jurisdictions for a user
 655        Returns a list of jurisdictions that the notary is registered in. The current user must be a notary.
 656        This method makes a synchronous HTTP request by default. To make an
 657        asynchronous HTTP request, please define a `callback` function
 658        to be invoked when receiving the response.
 659        >>> def callback_function(response):
 660        >>>     pprint(response)
 661        >>>
 662        >>> thread = api.get_notary_jurisdictions(callback=callback_function)
 663
 664        :param callback function: The callback function
 665            for asynchronous request. (optional)
 666        :return: NotaryJurisdictionList
 667                 If the method is called asynchronously,
 668                 returns the request thread.
 669        """
 670        kwargs['_return_http_data_only'] = True
 671        if kwargs.get('callback'):
 672            return self.get_notary_jurisdictions_with_http_info(**kwargs)
 673        else:
 674            (data) = self.get_notary_jurisdictions_with_http_info(**kwargs)
 675            return data
 676
 677    def get_notary_jurisdictions_with_http_info(self, **kwargs):
 678        """
 679        Get notary jurisdictions for a user
 680        Returns a list of jurisdictions that the notary is registered in. The current user must be a notary.
 681        This method makes a synchronous HTTP request by default. To make an
 682        asynchronous HTTP request, please define a `callback` function
 683        to be invoked when receiving the response.
 684        >>> def callback_function(response):
 685        >>>     pprint(response)
 686        >>>
 687        >>> thread = api.get_notary_jurisdictions_with_http_info(callback=callback_function)
 688
 689        :param callback function: The callback function
 690            for asynchronous request. (optional)
 691        :return: NotaryJurisdictionList
 692                 If the method is called asynchronously,
 693                 returns the request thread.
 694        """
 695
 696        all_params = []
 697        all_params.append('callback')
 698        all_params.append('_return_http_data_only')
 699        all_params.append('_preload_content')
 700        all_params.append('_request_timeout')
 701
 702        params = locals()
 703        for key, val in iteritems(params['kwargs']):
 704            if key not in all_params:
 705                raise TypeError(
 706                    "Got an unexpected keyword argument '%s'"
 707                    " to method get_notary_jurisdictions" % key
 708                )
 709            params[key] = val
 710        del params['kwargs']
 711
 712        collection_formats = {}
 713
 714        resource_path = '/v2.1/current_user/notary/jurisdictions'.replace('{format}', 'json')
 715        path_params = {}
 716
 717        query_params = {}
 718
 719        header_params = {}
 720
 721        form_params = []
 722        local_var_files = {}
 723
 724        body_params = None
 725        # HTTP header `Accept`
 726        header_params['Accept'] = self.api_client.\
 727            select_header_accept(['application/json'])
 728
 729        # Authentication setting
 730        auth_settings = []
 731
 732        return self.api_client.call_api(resource_path, 'GET',
 733                                        path_params,
 734                                        query_params,
 735                                        header_params,
 736                                        body=body_params,
 737                                        post_params=form_params,
 738                                        files=local_var_files,
 739                                        response_type='NotaryJurisdictionList',
 740                                        auth_settings=auth_settings,
 741                                        callback=params.get('callback'),
 742                                        _return_http_data_only=params.get('_return_http_data_only'),
 743                                        _preload_content=params.get('_preload_content', True),
 744                                        _request_timeout=params.get('_request_timeout'),
 745                                        collection_formats=collection_formats)
 746
 747    def list_notary_journals(self, **kwargs):
 748        """
 749        Get notary jurisdictions for a user
 750        
 751        This method makes a synchronous HTTP request by default. To make an
 752        asynchronous HTTP request, please define a `callback` function
 753        to be invoked when receiving the response.
 754        >>> def callback_function(response):
 755        >>>     pprint(response)
 756        >>>
 757        >>> thread = api.list_notary_journals(callback=callback_function)
 758
 759        :param callback function: The callback function
 760            for asynchronous request. (optional)
 761        :param str count:
 762        :param str search_text:
 763        :param str start_position:
 764        :return: NotaryJournalList
 765                 If the method is called asynchronously,
 766                 returns the request thread.
 767        """
 768        kwargs['_return_http_data_only'] = True
 769        if kwargs.get('callback'):
 770            return self.list_notary_journals_with_http_info(**kwargs)
 771        else:
 772            (data) = self.list_notary_journals_with_http_info(**kwargs)
 773            return data
 774
 775    def list_notary_journals_with_http_info(self, **kwargs):
 776        """
 777        Get notary jurisdictions for a user
 778        
 779        This method makes a synchronous HTTP request by default. To make an
 780        asynchronous HTTP request, please define a `callback` function
 781        to be invoked when receiving the response.
 782        >>> def callback_function(response):
 783        >>>     pprint(response)
 784        >>>
 785        >>> thread = api.list_notary_journals_with_http_info(callback=callback_function)
 786
 787        :param callback function: The callback function
 788            for asynchronous request. (optional)
 789        :param str count:
 790        :param str search_text:
 791        :param str start_position:
 792        :return: NotaryJournalList
 793                 If the method is called asynchronously,
 794                 returns the request thread.
 795        """
 796
 797        all_params = ['count', 'search_text', 'start_position']
 798        all_params.append('callback')
 799        all_params.append('_return_http_data_only')
 800        all_params.append('_preload_content')
 801        all_params.append('_request_timeout')
 802
 803        params = locals()
 804        for key, val in iteritems(params['kwargs']):
 805            if key not in all_params:
 806                raise TypeError(
 807                    "Got an unexpected keyword argument '%s'"
 808                    " to method list_notary_journals" % key
 809                )
 810            params[key] = val
 811        del params['kwargs']
 812
 813
 814        collection_formats = {}
 815
 816        resource_path = '/v2.1/current_user/notary/journals'.replace('{format}', 'json')
 817        path_params = {}
 818
 819        query_params = {}
 820        if 'count' in params:
 821            query_params['count'] = params['count']
 822        if 'search_text' in params:
 823            query_params['search_text'] = params['search_text']
 824        if 'start_position' in params:
 825            query_params['start_position'] = params['start_position']
 826
 827        header_params = {}
 828
 829        form_params = []
 830        local_var_files = {}
 831
 832        body_params = None
 833        # HTTP header `Accept`
 834        header_params['Accept'] = self.api_client.\
 835            select_header_accept(['application/json'])
 836
 837        # Authentication setting
 838        auth_settings = []
 839
 840        return self.api_client.call_api(resource_path, 'GET',
 841                                        path_params,
 842                                        query_params,
 843                                        header_params,
 844                                        body=body_params,
 845                                        post_params=form_params,
 846                                        files=local_var_files,
 847                                        response_type='NotaryJournalList',
 848                                        auth_settings=auth_settings,
 849                                        callback=params.get('callback'),
 850                                        _return_http_data_only=params.get('_return_http_data_only'),
 851                                        _preload_content=params.get('_preload_content', True),
 852                                        _request_timeout=params.get('_request_timeout'),
 853                                        collection_formats=collection_formats)
 854
 855    def update_notary(self, **kwargs):
 856        """
 857        Update a notary
 858        Updates notary information for the current user.
 859        This method makes a synchronous HTTP request by default. To make an
 860        asynchronous HTTP request, please define a `callback` function
 861        to be invoked when receiving the response.
 862        >>> def callback_function(response):
 863        >>>     pprint(response)
 864        >>>
 865        >>> thread = api.update_notary(callback=callback_function)
 866
 867        :param callback function: The callback function
 868            for asynchronous request. (optional)
 869        :param Notary notary:
 870        :return: Notary
 871                 If the method is called asynchronously,
 872                 returns the request thread.
 873        """
 874        kwargs['_return_http_data_only'] = True
 875        if kwargs.get('callback'):
 876            return self.update_notary_with_http_info(**kwargs)
 877        else:
 878            (data) = self.update_notary_with_http_info(**kwargs)
 879            return data
 880
 881    def update_notary_with_http_info(self, **kwargs):
 882        """
 883        Update a notary
 884        Updates notary information for the current user.
 885        This method makes a synchronous HTTP request by default. To make an
 886        asynchronous HTTP request, please define a `callback` function
 887        to be invoked when receiving the response.
 888        >>> def callback_function(response):
 889        >>>     pprint(response)
 890        >>>
 891        >>> thread = api.update_notary_with_http_info(callback=callback_function)
 892
 893        :param callback function: The callback function
 894            for asynchronous request. (optional)
 895        :param Notary notary:
 896        :return: Notary
 897                 If the method is called asynchronously,
 898                 returns the request thread.
 899        """
 900
 901        all_params = ['notary']
 902        all_params.append('callback')
 903        all_params.append('_return_http_data_only')
 904        all_params.append('_preload_content')
 905        all_params.append('_request_timeout')
 906
 907        params = locals()
 908        for key, val in iteritems(params['kwargs']):
 909            if key not in all_params:
 910                raise TypeError(
 911                    "Got an unexpected keyword argument '%s'"
 912                    " to method update_notary" % key
 913                )
 914            params[key] = val
 915        del params['kwargs']
 916
 917
 918        collection_formats = {}
 919
 920        resource_path = '/v2.1/current_user/notary'.replace('{format}', 'json')
 921        path_params = {}
 922
 923        query_params = {}
 924
 925        header_params = {}
 926
 927        form_params = []
 928        local_var_files = {}
 929
 930        body_params = None
 931        if 'notary' in params:
 932            body_params = params['notary']
 933        # HTTP header `Accept`
 934        header_params['Accept'] = self.api_client.\
 935            select_header_accept(['application/json'])
 936
 937        # Authentication setting
 938        auth_settings = []
 939
 940        return self.api_client.call_api(resource_path, 'PUT',
 941                                        path_params,
 942                                        query_params,
 943                                        header_params,
 944                                        body=body_params,
 945                                        post_params=form_params,
 946                                        files=local_var_files,
 947                                        response_type='Notary',
 948                                        auth_settings=auth_settings,
 949                                        callback=params.get('callback'),
 950                                        _return_http_data_only=params.get('_return_http_data_only'),
 951                                        _preload_content=params.get('_preload_content', True),
 952                                        _request_timeout=params.get('_request_timeout'),
 953                                        collection_formats=collection_formats)
 954
 955    def update_notary_jurisdiction(self, jurisdiction_id, **kwargs):
 956        """
 957        Update a notary jurisdiction
 958        Updates the jurisdiction information about a notary.  The following restrictions apply:  - The current user must be a notary. - The `jurisdictionId` path parameter must be a jurisdiction that the notary is registered for. - The `jurisdictionId` path parameter must match the request body's `jurisdiction.jurisdictionId`.  The request body must have a full `jurisdiction` object for the jurisdiction property. The best way to do this is to use `getNotaryJurisdiction` to obtain the current values and update the properties you want to change.  For example, assume `getNotaryJurisdiction` returns this:  ``` {     \"jurisdiction\": {         \"jurisdictionId\": \"15\",         \"name\": \"Iowa\",         \"county\": \"\",         \"enabled\": \"true\",         \"countyInSeal\": \"false\",         \"commissionIdInSeal\": \"true\",         \"stateNameInSeal\": \"true\",         \"notaryPublicInSeal\": \"true\",         \"allowSystemCreatedSeal\": \"true\",         \"allowUserUploadedSeal\": \"false\"     },     \"commissionId\": \"123456\",     \"commissionExpiration\": \"2020-08-31T07:00:00.0000000Z\",     \"registeredName\": \"Bob Notary\",     \"county\": \"Adams\",     \"sealType\": \"system_created\" } ```  If you want to change the name of the notary from \"Bob Notary\" to \"Robert Notary\", your request body would be:  ``` {     \"jurisdiction\": {         \"jurisdictionId\": \"15\",         \"name\": \"Iowa\",         \"county\": \"\",         \"enabled\": \"true\",         \"countyInSeal\": \"false\",         \"commissionIdInSeal\": \"true\",         \"stateNameInSeal\": \"true\",         \"notaryPublicInSeal\": \"true\",         \"allowSystemCreatedSeal\": \"true\",         \"allowUserUploadedSeal\": \"false\"     },     \"commissionId\": \"123456\",     \"commissionExpiration\": \"2020-08-31T07:00:00.0000000Z\",     \"registeredName\": \"Robert Notary\",     \"county\": \"Adams\",     \"sealType\": \"system_created\" } ``` 
 959        This method makes a synchronous HTTP request by default. To make an
 960        asynchronous HTTP request, please define a `callback` function
 961        to be invoked when receiving the response.
 962        >>> def callback_function(response):
 963        >>>     pprint(response)
 964        >>>
 965        >>> thread = api.update_notary_jurisdiction(jurisdiction_id, callback=callback_function)
 966
 967        :param callback function: The callback function
 968            for asynchronous request. (optional)
 969        :param str jurisdiction_id: (required)
 970        :param NotaryJurisdiction notary_jurisdiction:
 971        :return: NotaryJurisdiction
 972                 If the method is called asynchronously,
 973                 returns the request thread.
 974        """
 975        kwargs['_return_http_data_only'] = True
 976        if kwargs.get('callback'):
 977            return self.update_notary_jurisdiction_with_http_info(jurisdiction_id, **kwargs)
 978        else:
 979            (data) = self.update_notary_jurisdiction_with_http_info(jurisdiction_id, **kwargs)
 980            return data
 981
 982    def update_notary_jurisdiction_with_http_info(self, jurisdiction_id, **kwargs):
 983        """
 984        Update a notary jurisdiction
 985        Updates the jurisdiction information about a notary.  The following restrictions apply:  - The current user must be a notary. - The `jurisdictionId` path parameter must be a jurisdiction that the notary is registered for. - The `jurisdictionId` path parameter must match the request body's `jurisdiction.jurisdictionId`.  The request body must have a full `jurisdiction` object for the jurisdiction property. The best way to do this is to use `getNotaryJurisdiction` to obtain the current values and update the properties you want to change.  For example, assume `getNotaryJurisdiction` returns this:  ``` {     \"jurisdiction\": {         \"jurisdictionId\": \"15\",         \"name\": \"Iowa\",         \"county\": \"\",         \"enabled\": \"true\",         \"countyInSeal\": \"false\",         \"commissionIdInSeal\": \"true\",         \"stateNameInSeal\": \"true\",         \"notaryPublicInSeal\": \"true\",         \"allowSystemCreatedSeal\": \"true\",         \"allowUserUploadedSeal\": \"false\"     },     \"commissionId\": \"123456\",     \"commissionExpiration\": \"2020-08-31T07:00:00.0000000Z\",     \"registeredName\": \"Bob Notary\",     \"county\": \"Adams\",     \"sealType\": \"system_created\" } ```  If you want to change the name of the notary from \"Bob Notary\" to \"Robert Notary\", your request body would be:  ``` {     \"jurisdiction\": {         \"jurisdictionId\": \"15\",         \"name\": \"Iowa\",         \"county\": \"\",         \"enabled\": \"true\",         \"countyInSeal\": \"false\",         \"commissionIdInSeal\": \"true\",         \"stateNameInSeal\": \"true\",         \"notaryPublicInSeal\": \"true\",         \"allowSystemCreatedSeal\": \"true\",         \"allowUserUploadedSeal\": \"false\"     },     \"commissionId\": \"123456\",     \"commissionExpiration\": \"2020-08-31T07:00:00.0000000Z\",     \"registeredName\": \"Robert Notary\",     \"county\": \"Adams\",     \"sealType\": \"system_created\" } ``` 
 986        This method makes a synchronous HTTP request by default. To make an
 987        asynchronous HTTP request, please define a `callback` function
 988        to be invoked when receiving the response.
 989        >>> def callback_function(response):
 990        >>>     pprint(response)
 991        >>>
 992        >>> thread = api.update_notary_jurisdiction_with_http_info(jurisdiction_id, callback=callback_function)
 993
 994        :param callback function: The callback function
 995            for asynchronous request. (optional)
 996        :param str jurisdiction_id: (required)
 997        :param NotaryJurisdiction notary_jurisdiction:
 998        :return: NotaryJurisdiction
 999                 If the method is called asynchronously,
1000                 returns the request thread.
1001        """
1002
1003        all_params = ['jurisdiction_id', 'notary_jurisdiction']
1004        all_params.append('callback')
1005        all_params.append('_return_http_data_only')
1006        all_params.append('_preload_content')
1007        all_params.append('_request_timeout')
1008
1009        params = locals()
1010        for key, val in iteritems(params['kwargs']):
1011            if key not in all_params:
1012                raise TypeError(
1013                    "Got an unexpected keyword argument '%s'"
1014                    " to method update_notary_jurisdiction" % key
1015                )
1016            params[key] = val
1017        del params['kwargs']
1018        # verify the required parameter 'jurisdiction_id' is set
1019        if ('jurisdiction_id' not in params) or (params['jurisdiction_id'] is None):
1020            raise ValueError("Missing the required parameter `jurisdiction_id` when calling `update_notary_jurisdiction`")
1021
1022
1023        collection_formats = {}
1024
1025        resource_path = '/v2.1/current_user/notary/jurisdictions/{jurisdictionId}'.replace('{format}', 'json')
1026        path_params = {}
1027        if 'jurisdiction_id' in params:
1028            path_params['jurisdictionId'] = params['jurisdiction_id']
1029
1030        query_params = {}
1031
1032        header_params = {}
1033
1034        form_params = []
1035        local_var_files = {}
1036
1037        body_params = None
1038        if 'notary_jurisdiction' in params:
1039            body_params = params['notary_jurisdiction']
1040        # HTTP header `Accept`
1041        header_params['Accept'] = self.api_client.\
1042            select_header_accept(['application/json'])
1043
1044        # Authentication setting
1045        auth_settings = []
1046
1047        return self.api_client.call_api(resource_path, 'PUT',
1048                                        path_params,
1049                                        query_params,
1050                                        header_params,
1051                                        body=body_params,
1052                                        post_params=form_params,
1053                                        files=local_var_files,
1054                                        response_type='NotaryJurisdiction',
1055                                        auth_settings=auth_settings,
1056                                        callback=params.get('callback'),
1057                                        _return_http_data_only=params.get('_return_http_data_only'),
1058                                        _preload_content=params.get('_preload_content', True),
1059                                        _request_timeout=params.get('_request_timeout'),
1060                                        collection_formats=collection_formats)