def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

        def __period_get_autocomplete_v1(
            self,
            s_selector,
            **kwargs
        ):
            """Retrieve Periods and IDs  # noqa: E501

            Get the list of Periods to be used in a dropdown or autocomplete control.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.period_get_autocomplete_v1(s_selector, async_req=True)
            >>> result = thread.get()

            Args:
                s_selector (str): The types of Periods to return

            Keyword Args:
                s_query (str): Allow to filter on the option value. [optional]
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                CommonGetAutocompleteV1Response
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get(
                'async_req', False
            )
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True
            )
            kwargs['_preload_content'] = kwargs.get(
                '_preload_content', True
            )
            kwargs['_request_timeout'] = kwargs.get(
                '_request_timeout', None
            )
            kwargs['_check_input_type'] = kwargs.get(
                '_check_input_type', True
            )
            kwargs['_check_return_type'] = kwargs.get(
                '_check_return_type', True
            )
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['s_selector'] = \
                s_selector
            return self.call_with_http_info(**kwargs)

        self.period_get_autocomplete_v1 = _Endpoint(
            settings={
                'response_type': (CommonGetAutocompleteV1Response,),
                'auth': [
                    'Authorization'
                ],
                'endpoint_path': '/1/object/period/getAutocomplete/{sSelector}',
                'operation_id': 'period_get_autocomplete_v1',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    's_selector',
                    's_query',
                ],
                'required': [
                    's_selector',
                ],
                'nullable': [
                ],
                'enum': [
                    's_selector',
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                    ('s_selector',): {

                        "ACTIVENORMAL": "ActiveNormal",
                        "ACTIVENORMALANDENDOFYEAR": "ActiveNormalAndEndOfYear",
                        "ALLNORMAL": "AllNormal",
                        "ALLNORMALANDENDOFYEAR": "AllNormalAndEndOfYear"
                    },
                },
                'openapi_types': {
                    's_selector':
                        (str,),
                    's_query':
                        (str,),
                },
                'attribute_map': {
                    's_selector': 'sSelector',
                    's_query': 'sQuery',
                },
                'location_map': {
                    's_selector': 'path',
                    's_query': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__period_get_autocomplete_v1
        )
Exemple #2
0
    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

        def __ezsigndocument_apply_ezsigntemplate_v1(
                self, pki_ezsigndocument_id,
                ezsigndocument_apply_ezsigntemplate_v1_request, **kwargs):
            """Apply an Ezsign Template to the Ezsigndocument.  # noqa: E501

            This endpoint applies a predefined template to the ezsign document. This allows to automatically apply all the form and signature fields on a document in a single step.  The document must not already have fields otherwise an error will be returned.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.ezsigndocument_apply_ezsigntemplate_v1(pki_ezsigndocument_id, ezsigndocument_apply_ezsigntemplate_v1_request, async_req=True)
            >>> result = thread.get()

            Args:
                pki_ezsigndocument_id (int): The unique ID of the Ezsigndocument
                ezsigndocument_apply_ezsigntemplate_v1_request (EzsigndocumentApplyEzsigntemplateV1Request):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                EzsigndocumentApplyEzsigntemplateV1Response
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['pki_ezsigndocument_id'] = \
                pki_ezsigndocument_id
            kwargs['ezsigndocument_apply_ezsigntemplate_v1_request'] = \
                ezsigndocument_apply_ezsigntemplate_v1_request
            return self.call_with_http_info(**kwargs)

        self.ezsigndocument_apply_ezsigntemplate_v1 = _Endpoint(
            settings={
                'response_type':
                (EzsigndocumentApplyEzsigntemplateV1Response, ),
                'auth': ['Authorization'],
                'endpoint_path':
                '/1/object/ezsigndocument/{pkiEzsigndocumentID}/applyezsigntemplate',
                'operation_id': 'ezsigndocument_apply_ezsigntemplate_v1',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'pki_ezsigndocument_id',
                    'ezsigndocument_apply_ezsigntemplate_v1_request',
                ],
                'required': [
                    'pki_ezsigndocument_id',
                    'ezsigndocument_apply_ezsigntemplate_v1_request',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'pki_ezsigndocument_id': (int, ),
                    'ezsigndocument_apply_ezsigntemplate_v1_request':
                    (EzsigndocumentApplyEzsigntemplateV1Request, ),
                },
                'attribute_map': {
                    'pki_ezsigndocument_id': 'pkiEzsigndocumentID',
                },
                'location_map': {
                    'pki_ezsigndocument_id': 'path',
                    'ezsigndocument_apply_ezsigntemplate_v1_request': 'body',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': ['application/json']
            },
            api_client=api_client,
            callable=__ezsigndocument_apply_ezsigntemplate_v1)

        def __ezsigndocument_create_object_v1(
                self, ezsigndocument_create_object_v1_request, **kwargs):
            """Create a new Ezsigndocument  # noqa: E501

            The endpoint allows to create one or many elements at once.  The array can contain simple (Just the object) or compound (The object and its child) objects.  Creating compound elements allows to reduce the multiple requests to create all child objects.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.ezsigndocument_create_object_v1(ezsigndocument_create_object_v1_request, async_req=True)
            >>> result = thread.get()

            Args:
                ezsigndocument_create_object_v1_request ([EzsigndocumentCreateObjectV1Request]):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                EzsigndocumentCreateObjectV1Response
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['ezsigndocument_create_object_v1_request'] = \
                ezsigndocument_create_object_v1_request
            return self.call_with_http_info(**kwargs)

        self.ezsigndocument_create_object_v1 = _Endpoint(
            settings={
                'response_type': (EzsigndocumentCreateObjectV1Response, ),
                'auth': ['Authorization'],
                'endpoint_path': '/1/object/ezsigndocument',
                'operation_id': 'ezsigndocument_create_object_v1',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'ezsigndocument_create_object_v1_request',
                ],
                'required': [
                    'ezsigndocument_create_object_v1_request',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'ezsigndocument_create_object_v1_request':
                    ([EzsigndocumentCreateObjectV1Request], ),
                },
                'attribute_map': {},
                'location_map': {
                    'ezsigndocument_create_object_v1_request': 'body',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': ['application/json']
            },
            api_client=api_client,
            callable=__ezsigndocument_create_object_v1)

        def __ezsigndocument_delete_object_v1(self, pki_ezsigndocument_id,
                                              **kwargs):
            """Delete an existing Ezsigndocument  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.ezsigndocument_delete_object_v1(pki_ezsigndocument_id, async_req=True)
            >>> result = thread.get()

            Args:
                pki_ezsigndocument_id (int): The unique ID of the Ezsigndocument

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                EzsigndocumentDeleteObjectV1Response
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['pki_ezsigndocument_id'] = \
                pki_ezsigndocument_id
            return self.call_with_http_info(**kwargs)

        self.ezsigndocument_delete_object_v1 = _Endpoint(
            settings={
                'response_type': (EzsigndocumentDeleteObjectV1Response, ),
                'auth': ['Authorization'],
                'endpoint_path':
                '/1/object/ezsigndocument/{pkiEzsigndocumentID}',
                'operation_id': 'ezsigndocument_delete_object_v1',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'pki_ezsigndocument_id',
                ],
                'required': [
                    'pki_ezsigndocument_id',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'pki_ezsigndocument_id': (int, ),
                },
                'attribute_map': {
                    'pki_ezsigndocument_id': 'pkiEzsigndocumentID',
                },
                'location_map': {
                    'pki_ezsigndocument_id': 'path',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': [],
            },
            api_client=api_client,
            callable=__ezsigndocument_delete_object_v1)

        def __ezsigndocument_get_children_v1(self, pki_ezsigndocument_id,
                                             **kwargs):
            """Retrieve an existing Ezsigndocument's children IDs  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.ezsigndocument_get_children_v1(pki_ezsigndocument_id, async_req=True)
            >>> result = thread.get()

            Args:
                pki_ezsigndocument_id (int): The unique ID of the Ezsigndocument

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                None
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['pki_ezsigndocument_id'] = \
                pki_ezsigndocument_id
            return self.call_with_http_info(**kwargs)

        self.ezsigndocument_get_children_v1 = _Endpoint(
            settings={
                'response_type': None,
                'auth': ['Authorization'],
                'endpoint_path':
                '/1/object/ezsigndocument/{pkiEzsigndocumentID}/getChildren',
                'operation_id': 'ezsigndocument_get_children_v1',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'pki_ezsigndocument_id',
                ],
                'required': [
                    'pki_ezsigndocument_id',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'pki_ezsigndocument_id': (int, ),
                },
                'attribute_map': {
                    'pki_ezsigndocument_id': 'pkiEzsigndocumentID',
                },
                'location_map': {
                    'pki_ezsigndocument_id': 'path',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': [],
            },
            api_client=api_client,
            callable=__ezsigndocument_get_children_v1)

        def __ezsigndocument_get_download_url_v1(self, pki_ezsigndocument_id,
                                                 e_document_type, **kwargs):
            """Retrieve a URL to download documents.  # noqa: E501

            This endpoint returns URLs to different files that can be downloaded during the signing process.  These links will expire after 5 minutes so the download of the file should be made soon after retrieving the link.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.ezsigndocument_get_download_url_v1(pki_ezsigndocument_id, e_document_type, async_req=True)
            >>> result = thread.get()

            Args:
                pki_ezsigndocument_id (int): The unique ID of the Ezsigndocument
                e_document_type (str): The type of document to retrieve.  1. **Initial** Is the initial document before any signature were applied. 2. **Signed** Is the final document once all signatures were applied. 3. **Proofdocument** Is the evidence report. 4. **Proof** Is the complete evidence archive including all of the above and more. 

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                EzsigndocumentGetDownloadUrlV1Response
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['pki_ezsigndocument_id'] = \
                pki_ezsigndocument_id
            kwargs['e_document_type'] = \
                e_document_type
            return self.call_with_http_info(**kwargs)

        self.ezsigndocument_get_download_url_v1 = _Endpoint(
            settings={
                'response_type': (EzsigndocumentGetDownloadUrlV1Response, ),
                'auth': ['Authorization'],
                'endpoint_path':
                '/1/object/ezsigndocument/{pkiEzsigndocumentID}/getDownloadUrl/{eDocumentType}',
                'operation_id': 'ezsigndocument_get_download_url_v1',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'pki_ezsigndocument_id',
                    'e_document_type',
                ],
                'required': [
                    'pki_ezsigndocument_id',
                    'e_document_type',
                ],
                'nullable': [],
                'enum': [
                    'e_document_type',
                ],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {
                    ('e_document_type', ): {
                        "INITIAL": "Initial",
                        "SIGNED": "Signed",
                        "PROOF": "Proof",
                        "PROOFDOCUMENT": "Proofdocument"
                    },
                },
                'openapi_types': {
                    'pki_ezsigndocument_id': (int, ),
                    'e_document_type': (str, ),
                },
                'attribute_map': {
                    'pki_ezsigndocument_id': 'pkiEzsigndocumentID',
                    'e_document_type': 'eDocumentType',
                },
                'location_map': {
                    'pki_ezsigndocument_id': 'path',
                    'e_document_type': 'path',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': [],
            },
            api_client=api_client,
            callable=__ezsigndocument_get_download_url_v1)

        def __ezsigndocument_get_object_v1(self, pki_ezsigndocument_id,
                                           **kwargs):
            """Retrieve an existing Ezsigndocument  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.ezsigndocument_get_object_v1(pki_ezsigndocument_id, async_req=True)
            >>> result = thread.get()

            Args:
                pki_ezsigndocument_id (int): The unique ID of the Ezsigndocument

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                EzsigndocumentGetObjectV1Response
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['pki_ezsigndocument_id'] = \
                pki_ezsigndocument_id
            return self.call_with_http_info(**kwargs)

        self.ezsigndocument_get_object_v1 = _Endpoint(
            settings={
                'response_type': (EzsigndocumentGetObjectV1Response, ),
                'auth': ['Authorization'],
                'endpoint_path':
                '/1/object/ezsigndocument/{pkiEzsigndocumentID}',
                'operation_id': 'ezsigndocument_get_object_v1',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'pki_ezsigndocument_id',
                ],
                'required': [
                    'pki_ezsigndocument_id',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'pki_ezsigndocument_id': (int, ),
                },
                'attribute_map': {
                    'pki_ezsigndocument_id': 'pkiEzsigndocumentID',
                },
                'location_map': {
                    'pki_ezsigndocument_id': 'path',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': [],
            },
            api_client=api_client,
            callable=__ezsigndocument_get_object_v1)
    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

        def __global_customer_get_endpoint_v1(self, pks_customer_code,
                                              **kwargs):
            """Get customer endpoint  # noqa: E501

            Retrieve the customer's specific server endpoint where to send requests. This will help locate the proper region (ie: sInfrastructureregionCode) and the proper environment (ie: sInfrastructureenvironmenttypeDescription) where the customer's data is stored.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.global_customer_get_endpoint_v1(pks_customer_code, async_req=True)
            >>> result = thread.get()

            Args:
                pks_customer_code (str): The customer code assigned to your account

            Keyword Args:
                s_infrastructureproduct_code (str): The infrastructure product Code  If undefined, \"appcluster01\" is assumed. [optional]
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                GlobalCustomerGetEndpointV1Response
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['pks_customer_code'] = \
                pks_customer_code
            return self.call_with_http_info(**kwargs)

        self.global_customer_get_endpoint_v1 = _Endpoint(
            settings={
                'response_type': (GlobalCustomerGetEndpointV1Response, ),
                'auth': ['Authorization'],
                'endpoint_path': '/1/customer/{pksCustomerCode}/endpoint',
                'operation_id': 'global_customer_get_endpoint_v1',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'pks_customer_code',
                    's_infrastructureproduct_code',
                ],
                'required': [
                    'pks_customer_code',
                ],
                'nullable': [],
                'enum': [
                    's_infrastructureproduct_code',
                ],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {
                    ('s_infrastructureproduct_code', ): {
                        "APPCLUSTER01": "appcluster01",
                        "EZSIGNUSER": "******"
                    },
                },
                'openapi_types': {
                    'pks_customer_code': (str, ),
                    's_infrastructureproduct_code': (str, ),
                },
                'attribute_map': {
                    'pks_customer_code': 'pksCustomerCode',
                    's_infrastructureproduct_code':
                    'sInfrastructureproductCode',
                },
                'location_map': {
                    'pks_customer_code': 'path',
                    's_infrastructureproduct_code': 'query',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': [],
            },
            api_client=api_client,
            callable=__global_customer_get_endpoint_v1)
Exemple #4
0
    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

        def __apikey_create_object_v1(self, apikey_create_object_v1_request,
                                      **kwargs):
            """Create a new Apikey  # noqa: E501

            The endpoint allows to create one or many elements at once.  The array can contain simple (Just the object) or compound (The object and its child) objects.  Creating compound elements allows to reduce the multiple requests to create all child objects.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.apikey_create_object_v1(apikey_create_object_v1_request, async_req=True)
            >>> result = thread.get()

            Args:
                apikey_create_object_v1_request ([ApikeyCreateObjectV1Request]):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                ApikeyCreateObjectV1Response
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['apikey_create_object_v1_request'] = \
                apikey_create_object_v1_request
            return self.call_with_http_info(**kwargs)

        self.apikey_create_object_v1 = _Endpoint(
            settings={
                'response_type': (ApikeyCreateObjectV1Response, ),
                'auth': ['Authorization'],
                'endpoint_path': '/1/object/apikey',
                'operation_id': 'apikey_create_object_v1',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'apikey_create_object_v1_request',
                ],
                'required': [
                    'apikey_create_object_v1_request',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'apikey_create_object_v1_request':
                    ([ApikeyCreateObjectV1Request], ),
                },
                'attribute_map': {},
                'location_map': {
                    'apikey_create_object_v1_request': 'body',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': ['application/json']
            },
            api_client=api_client,
            callable=__apikey_create_object_v1)
Exemple #5
0
    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

        def __ezsignfoldersignerassociation_create_object_v1(
                self, ezsignfoldersignerassociation_create_object_v1_request,
                **kwargs):
            """Create a new Ezsignfoldersignerassociation  # noqa: E501

            The endpoint allows to create one or many elements at once.  The array can contain simple (Just the object) or compound (The object and its child) objects.  Creating compound elements allows to reduce the multiple requests to create all child objects.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.ezsignfoldersignerassociation_create_object_v1(ezsignfoldersignerassociation_create_object_v1_request, async_req=True)
            >>> result = thread.get()

            Args:
                ezsignfoldersignerassociation_create_object_v1_request ([EzsignfoldersignerassociationCreateObjectV1Request]):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                EzsignfoldersignerassociationCreateObjectV1Response
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['ezsignfoldersignerassociation_create_object_v1_request'] = \
                ezsignfoldersignerassociation_create_object_v1_request
            return self.call_with_http_info(**kwargs)

        self.ezsignfoldersignerassociation_create_object_v1 = _Endpoint(
            settings={
                'response_type':
                (EzsignfoldersignerassociationCreateObjectV1Response, ),
                'auth': ['Authorization'],
                'endpoint_path':
                '/1/object/ezsignfoldersignerassociation',
                'operation_id':
                'ezsignfoldersignerassociation_create_object_v1',
                'http_method':
                'POST',
                'servers':
                None,
            },
            params_map={
                'all': [
                    'ezsignfoldersignerassociation_create_object_v1_request',
                ],
                'required': [
                    'ezsignfoldersignerassociation_create_object_v1_request',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'ezsignfoldersignerassociation_create_object_v1_request':
                    ([EzsignfoldersignerassociationCreateObjectV1Request], ),
                },
                'attribute_map': {},
                'location_map': {
                    'ezsignfoldersignerassociation_create_object_v1_request':
                    'body',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': ['application/json']
            },
            api_client=api_client,
            callable=__ezsignfoldersignerassociation_create_object_v1)

        def __ezsignfoldersignerassociation_delete_object_v1(
                self, pki_ezsignfoldersignerassociation_id, **kwargs):
            """Delete an existing Ezsignfoldersignerassociation  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.ezsignfoldersignerassociation_delete_object_v1(pki_ezsignfoldersignerassociation_id, async_req=True)
            >>> result = thread.get()

            Args:
                pki_ezsignfoldersignerassociation_id (int): The unique ID of the Ezsignfoldersignerassociation

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                EzsignfoldersignerassociationDeleteObjectV1Response
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['pki_ezsignfoldersignerassociation_id'] = \
                pki_ezsignfoldersignerassociation_id
            return self.call_with_http_info(**kwargs)

        self.ezsignfoldersignerassociation_delete_object_v1 = _Endpoint(
            settings={
                'response_type':
                (EzsignfoldersignerassociationDeleteObjectV1Response, ),
                'auth': ['Authorization'],
                'endpoint_path':
                '/1/object/ezsignfoldersignerassociation/{pkiEzsignfoldersignerassociationID}',
                'operation_id':
                'ezsignfoldersignerassociation_delete_object_v1',
                'http_method':
                'DELETE',
                'servers':
                None,
            },
            params_map={
                'all': [
                    'pki_ezsignfoldersignerassociation_id',
                ],
                'required': [
                    'pki_ezsignfoldersignerassociation_id',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'pki_ezsignfoldersignerassociation_id': (int, ),
                },
                'attribute_map': {
                    'pki_ezsignfoldersignerassociation_id':
                    'pkiEzsignfoldersignerassociationID',
                },
                'location_map': {
                    'pki_ezsignfoldersignerassociation_id': 'path',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': [],
            },
            api_client=api_client,
            callable=__ezsignfoldersignerassociation_delete_object_v1)

        def __ezsignfoldersignerassociation_get_children_v1(
                self, pki_ezsignfoldersignerassociation_id, **kwargs):
            """Retrieve an existing Ezsignfoldersignerassociation's children IDs  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.ezsignfoldersignerassociation_get_children_v1(pki_ezsignfoldersignerassociation_id, async_req=True)
            >>> result = thread.get()

            Args:
                pki_ezsignfoldersignerassociation_id (int): The unique ID of the Ezsignfoldersignerassociation

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                None
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['pki_ezsignfoldersignerassociation_id'] = \
                pki_ezsignfoldersignerassociation_id
            return self.call_with_http_info(**kwargs)

        self.ezsignfoldersignerassociation_get_children_v1 = _Endpoint(
            settings={
                'response_type': None,
                'auth': ['Authorization'],
                'endpoint_path':
                '/1/object/ezsignfoldersignerassociation/{pkiEzsignfoldersignerassociationID}/getChildren',
                'operation_id':
                'ezsignfoldersignerassociation_get_children_v1',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'pki_ezsignfoldersignerassociation_id',
                ],
                'required': [
                    'pki_ezsignfoldersignerassociation_id',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'pki_ezsignfoldersignerassociation_id': (int, ),
                },
                'attribute_map': {
                    'pki_ezsignfoldersignerassociation_id':
                    'pkiEzsignfoldersignerassociationID',
                },
                'location_map': {
                    'pki_ezsignfoldersignerassociation_id': 'path',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': [],
            },
            api_client=api_client,
            callable=__ezsignfoldersignerassociation_get_children_v1)

        def __ezsignfoldersignerassociation_get_in_person_login_url_v1(
                self, pki_ezsignfoldersignerassociation_id, **kwargs):
            """Retrieve a Login Url to allow In-Person signing  # noqa: E501

            This endpoint returns a Login Url that can be used in a browser or embedded in an I-Frame to allow in person signing.  The signer Login type must be configured as In-Person.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.ezsignfoldersignerassociation_get_in_person_login_url_v1(pki_ezsignfoldersignerassociation_id, async_req=True)
            >>> result = thread.get()

            Args:
                pki_ezsignfoldersignerassociation_id (int): The unique ID of the Ezsignfoldersignerassociation

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                EzsignfoldersignerassociationGetInPersonLoginUrlV1Response
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['pki_ezsignfoldersignerassociation_id'] = \
                pki_ezsignfoldersignerassociation_id
            return self.call_with_http_info(**kwargs)

        self.ezsignfoldersignerassociation_get_in_person_login_url_v1 = _Endpoint(
            settings={
                'response_type':
                (EzsignfoldersignerassociationGetInPersonLoginUrlV1Response, ),
                'auth': ['Authorization'],
                'endpoint_path':
                '/1/object/ezsignfoldersignerassociation/{pkiEzsignfoldersignerassociationID}/getInPersonLoginUrl',
                'operation_id':
                'ezsignfoldersignerassociation_get_in_person_login_url_v1',
                'http_method':
                'GET',
                'servers':
                None,
            },
            params_map={
                'all': [
                    'pki_ezsignfoldersignerassociation_id',
                ],
                'required': [
                    'pki_ezsignfoldersignerassociation_id',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'pki_ezsignfoldersignerassociation_id': (int, ),
                },
                'attribute_map': {
                    'pki_ezsignfoldersignerassociation_id':
                    'pkiEzsignfoldersignerassociationID',
                },
                'location_map': {
                    'pki_ezsignfoldersignerassociation_id': 'path',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': [],
            },
            api_client=api_client,
            callable=__ezsignfoldersignerassociation_get_in_person_login_url_v1
        )

        def __ezsignfoldersignerassociation_get_object_v1(
                self, pki_ezsignfoldersignerassociation_id, **kwargs):
            """Retrieve an existing Ezsignfoldersignerassociation  # noqa: E501

            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.ezsignfoldersignerassociation_get_object_v1(pki_ezsignfoldersignerassociation_id, async_req=True)
            >>> result = thread.get()

            Args:
                pki_ezsignfoldersignerassociation_id (int): The unique ID of the Ezsignfoldersignerassociation

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                EzsignfoldersignerassociationGetObjectV1Response
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['pki_ezsignfoldersignerassociation_id'] = \
                pki_ezsignfoldersignerassociation_id
            return self.call_with_http_info(**kwargs)

        self.ezsignfoldersignerassociation_get_object_v1 = _Endpoint(
            settings={
                'response_type':
                (EzsignfoldersignerassociationGetObjectV1Response, ),
                'auth': ['Authorization'],
                'endpoint_path':
                '/1/object/ezsignfoldersignerassociation/{pkiEzsignfoldersignerassociationID}',
                'operation_id':
                'ezsignfoldersignerassociation_get_object_v1',
                'http_method':
                'GET',
                'servers':
                None,
            },
            params_map={
                'all': [
                    'pki_ezsignfoldersignerassociation_id',
                ],
                'required': [
                    'pki_ezsignfoldersignerassociation_id',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'pki_ezsignfoldersignerassociation_id': (int, ),
                },
                'attribute_map': {
                    'pki_ezsignfoldersignerassociation_id':
                    'pkiEzsignfoldersignerassociationID',
                },
                'location_map': {
                    'pki_ezsignfoldersignerassociation_id': 'path',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': [],
            },
            api_client=api_client,
            callable=__ezsignfoldersignerassociation_get_object_v1)
Exemple #6
0
    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

        def __sspr_reset_password_request_v1(
                self, sspr_reset_password_request_v1_request, **kwargs):
            """Reset Password Request  # noqa: E501

            This endpoint sends an email with a link to reset the user's password.  sEmailAddress must be set if eUserTypeSSPR = EzsignUser  sUserLoginname must be set if eUserTypeSSPR = Native  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.sspr_reset_password_request_v1(sspr_reset_password_request_v1_request, async_req=True)
            >>> result = thread.get()

            Args:
                sspr_reset_password_request_v1_request (SsprResetPasswordRequestV1Request):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                None
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['sspr_reset_password_request_v1_request'] = \
                sspr_reset_password_request_v1_request
            return self.call_with_http_info(**kwargs)

        self.sspr_reset_password_request_v1 = _Endpoint(
            settings={
                'response_type': None,
                'auth': ['Authorization'],
                'endpoint_path': '/1/module/sspr/resetPasswordRequest',
                'operation_id': 'sspr_reset_password_request_v1',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sspr_reset_password_request_v1_request',
                ],
                'required': [
                    'sspr_reset_password_request_v1_request',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'sspr_reset_password_request_v1_request':
                    (SsprResetPasswordRequestV1Request, ),
                },
                'attribute_map': {},
                'location_map': {
                    'sspr_reset_password_request_v1_request': 'body',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': ['application/json']
            },
            api_client=api_client,
            callable=__sspr_reset_password_request_v1)

        def __sspr_reset_password_v1(self, sspr_reset_password_v1_request,
                                     **kwargs):
            """Reset Password  # noqa: E501

            This endpoint resets the user's password.  sEmailAddress must be set if eUserTypeSSPR = EzsignUser  sUserLoginname must be set if eUserTypeSSPR = Native  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.sspr_reset_password_v1(sspr_reset_password_v1_request, async_req=True)
            >>> result = thread.get()

            Args:
                sspr_reset_password_v1_request (SsprResetPasswordV1Request):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                None
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['sspr_reset_password_v1_request'] = \
                sspr_reset_password_v1_request
            return self.call_with_http_info(**kwargs)

        self.sspr_reset_password_v1 = _Endpoint(
            settings={
                'response_type': None,
                'auth': ['Authorization'],
                'endpoint_path': '/1/module/sspr/resetPassword',
                'operation_id': 'sspr_reset_password_v1',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sspr_reset_password_v1_request',
                ],
                'required': [
                    'sspr_reset_password_v1_request',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'sspr_reset_password_v1_request':
                    (SsprResetPasswordV1Request, ),
                },
                'attribute_map': {},
                'location_map': {
                    'sspr_reset_password_v1_request': 'body',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': ['application/json']
            },
            api_client=api_client,
            callable=__sspr_reset_password_v1)

        def __sspr_send_usernames_v1(self, sspr_send_usernames_v1_request,
                                     **kwargs):
            """Send username(s)  # noqa: E501

            This endpoint returns an email with the username(s) matching the email address provided in case of forgotten username  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.sspr_send_usernames_v1(sspr_send_usernames_v1_request, async_req=True)
            >>> result = thread.get()

            Args:
                sspr_send_usernames_v1_request (SsprSendUsernamesV1Request):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                None
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['sspr_send_usernames_v1_request'] = \
                sspr_send_usernames_v1_request
            return self.call_with_http_info(**kwargs)

        self.sspr_send_usernames_v1 = _Endpoint(
            settings={
                'response_type': None,
                'auth': ['Authorization'],
                'endpoint_path': '/1/module/sspr/sendUsernames',
                'operation_id': 'sspr_send_usernames_v1',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sspr_send_usernames_v1_request',
                ],
                'required': [
                    'sspr_send_usernames_v1_request',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'sspr_send_usernames_v1_request':
                    (SsprSendUsernamesV1Request, ),
                },
                'attribute_map': {},
                'location_map': {
                    'sspr_send_usernames_v1_request': 'body',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': ['application/json']
            },
            api_client=api_client,
            callable=__sspr_send_usernames_v1)

        def __sspr_unlock_account_request_v1(
                self, sspr_unlock_account_request_v1_request, **kwargs):
            """Unlock Account Request  # noqa: E501

            This endpoint sends an email with a link to unlock the user account.  sEmailAddress must be set if eUserTypeSSPR = EzsignUser  sUserLoginname must be set if eUserTypeSSPR = Native  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.sspr_unlock_account_request_v1(sspr_unlock_account_request_v1_request, async_req=True)
            >>> result = thread.get()

            Args:
                sspr_unlock_account_request_v1_request (SsprUnlockAccountRequestV1Request):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                None
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['sspr_unlock_account_request_v1_request'] = \
                sspr_unlock_account_request_v1_request
            return self.call_with_http_info(**kwargs)

        self.sspr_unlock_account_request_v1 = _Endpoint(
            settings={
                'response_type': None,
                'auth': ['Authorization'],
                'endpoint_path': '/1/module/sspr/unlockAccountRequest',
                'operation_id': 'sspr_unlock_account_request_v1',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sspr_unlock_account_request_v1_request',
                ],
                'required': [
                    'sspr_unlock_account_request_v1_request',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'sspr_unlock_account_request_v1_request':
                    (SsprUnlockAccountRequestV1Request, ),
                },
                'attribute_map': {},
                'location_map': {
                    'sspr_unlock_account_request_v1_request': 'body',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': ['application/json']
            },
            api_client=api_client,
            callable=__sspr_unlock_account_request_v1)

        def __sspr_unlock_account_v1(self, sspr_unlock_account_v1_request,
                                     **kwargs):
            """Unlock Account  # noqa: E501

            This endpoint unlocks the user account.  sEmailAddress must be set if eUserTypeSSPR = EzsignUser  sUserLoginname must be set if eUserTypeSSPR = Native  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.sspr_unlock_account_v1(sspr_unlock_account_v1_request, async_req=True)
            >>> result = thread.get()

            Args:
                sspr_unlock_account_v1_request (SsprUnlockAccountV1Request):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                None
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['sspr_unlock_account_v1_request'] = \
                sspr_unlock_account_v1_request
            return self.call_with_http_info(**kwargs)

        self.sspr_unlock_account_v1 = _Endpoint(
            settings={
                'response_type': None,
                'auth': ['Authorization'],
                'endpoint_path': '/1/module/sspr/unlockAccount',
                'operation_id': 'sspr_unlock_account_v1',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sspr_unlock_account_v1_request',
                ],
                'required': [
                    'sspr_unlock_account_v1_request',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'sspr_unlock_account_v1_request':
                    (SsprUnlockAccountV1Request, ),
                },
                'attribute_map': {},
                'location_map': {
                    'sspr_unlock_account_v1_request': 'body',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': ['application/json']
            },
            api_client=api_client,
            callable=__sspr_unlock_account_v1)

        def __sspr_validate_token_v1(self, sspr_validate_token_v1_request,
                                     **kwargs):
            """Validate Token  # noqa: E501

            This endpoint validates if a Token is valid and not expired.  sEmailAddress must be set if eUserTypeSSPR = EzsignUser  sUserLoginname must be set if eUserTypeSSPR = Native  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.sspr_validate_token_v1(sspr_validate_token_v1_request, async_req=True)
            >>> result = thread.get()

            Args:
                sspr_validate_token_v1_request (SsprValidateTokenV1Request):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                None
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['sspr_validate_token_v1_request'] = \
                sspr_validate_token_v1_request
            return self.call_with_http_info(**kwargs)

        self.sspr_validate_token_v1 = _Endpoint(
            settings={
                'response_type': None,
                'auth': ['Authorization'],
                'endpoint_path': '/1/module/sspr/validateToken',
                'operation_id': 'sspr_validate_token_v1',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sspr_validate_token_v1_request',
                ],
                'required': [
                    'sspr_validate_token_v1_request',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'sspr_validate_token_v1_request':
                    (SsprValidateTokenV1Request, ),
                },
                'attribute_map': {},
                'location_map': {
                    'sspr_validate_token_v1_request': 'body',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': ['application/json']
            },
            api_client=api_client,
            callable=__sspr_validate_token_v1)
    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

        def __activesession_get_current_v1(self, **kwargs):
            """Get Current Activesession  # noqa: E501

            Retrieve the details about the current activesession  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.activesession_get_current_v1(async_req=True)
            >>> result = thread.get()


            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                ActivesessionGetCurrentV1Response
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            return self.call_with_http_info(**kwargs)

        self.activesession_get_current_v1 = _Endpoint(
            settings={
                'response_type': (ActivesessionGetCurrentV1Response, ),
                'auth': ['Authorization'],
                'endpoint_path': '/1/object/activesession/getCurrent',
                'operation_id': 'activesession_get_current_v1',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [],
                'required': [],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {},
                'attribute_map': {},
                'location_map': {},
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': [],
            },
            api_client=api_client,
            callable=__activesession_get_current_v1)
    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

        def __user_create_ezsignuser_v1(self,
                                        user_create_ezsignuser_v1_request,
                                        **kwargs):
            """Create a new User of type Ezsignuser  # noqa: E501

            The endpoint allows to initiate the creation or a user of type Ezsignuser.  The user will be created only once the email verification process will be completed  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.user_create_ezsignuser_v1(user_create_ezsignuser_v1_request, async_req=True)
            >>> result = thread.get()

            Args:
                user_create_ezsignuser_v1_request ([UserCreateEzsignuserV1Request]):

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                UserCreateEzsignuserV1Response
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['user_create_ezsignuser_v1_request'] = \
                user_create_ezsignuser_v1_request
            return self.call_with_http_info(**kwargs)

        self.user_create_ezsignuser_v1 = _Endpoint(
            settings={
                'response_type': (UserCreateEzsignuserV1Response, ),
                'auth': ['Authorization'],
                'endpoint_path': '/1/module/user/createezsignuser',
                'operation_id': 'user_create_ezsignuser_v1',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'user_create_ezsignuser_v1_request',
                ],
                'required': [
                    'user_create_ezsignuser_v1_request',
                ],
                'nullable': [],
                'enum': [],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {},
                'openapi_types': {
                    'user_create_ezsignuser_v1_request':
                    ([UserCreateEzsignuserV1Request], ),
                },
                'attribute_map': {},
                'location_map': {
                    'user_create_ezsignuser_v1_request': 'body',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': ['application/json']
            },
            api_client=api_client,
            callable=__user_create_ezsignuser_v1)
    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

        def __authenticate_authenticate_v2(
                self,
                authenticate_authenticate_v2_request,
                e_session_type="ezsignuser",
                **kwargs):
            """Authenticate a user  # noqa: E501

            This endpoint authenticates a user.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.authenticate_authenticate_v2(authenticate_authenticate_v2_request, e_session_type="ezsignuser", async_req=True)
            >>> result = thread.get()

            Args:
                authenticate_authenticate_v2_request (AuthenticateAuthenticateV2Request):
                e_session_type (str): defaults to "ezsignuser", must be one of ["ezsignuser"]

            Keyword Args:
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

            Returns:
                AuthenticateAuthenticateV2Response
                    If the method is called asynchronously, returns the request
                    thread.
            """
            kwargs['async_req'] = kwargs.get('async_req', False)
            kwargs['_return_http_data_only'] = kwargs.get(
                '_return_http_data_only', True)
            kwargs['_preload_content'] = kwargs.get('_preload_content', True)
            kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
            kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
            kwargs['_check_return_type'] = kwargs.get('_check_return_type',
                                                      True)
            kwargs['_host_index'] = kwargs.get('_host_index')
            kwargs['e_session_type'] = \
                e_session_type
            kwargs['authenticate_authenticate_v2_request'] = \
                authenticate_authenticate_v2_request
            return self.call_with_http_info(**kwargs)

        self.authenticate_authenticate_v2 = _Endpoint(
            settings={
                'response_type': (AuthenticateAuthenticateV2Response, ),
                'auth': ['Authorization'],
                'endpoint_path':
                '/2/module/authenticate/authenticate/{eSessionType}',
                'operation_id': 'authenticate_authenticate_v2',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'e_session_type',
                    'authenticate_authenticate_v2_request',
                ],
                'required': [
                    'e_session_type',
                    'authenticate_authenticate_v2_request',
                ],
                'nullable': [],
                'enum': [
                    'e_session_type',
                ],
                'validation': []
            },
            root_map={
                'validations': {},
                'allowed_values': {
                    ('e_session_type', ): {
                        "EZSIGNUSER": "******"
                    },
                },
                'openapi_types': {
                    'e_session_type': (str, ),
                    'authenticate_authenticate_v2_request':
                    (AuthenticateAuthenticateV2Request, ),
                },
                'attribute_map': {
                    'e_session_type': 'eSessionType',
                },
                'location_map': {
                    'e_session_type': 'path',
                    'authenticate_authenticate_v2_request': 'body',
                },
                'collection_format_map': {}
            },
            headers_map={
                'accept': ['application/json'],
                'content_type': ['application/json']
            },
            api_client=api_client,
            callable=__authenticate_authenticate_v2)