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
)
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)
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)
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)
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)