def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __segments_by_name_delete(self, name, **kwargs):
"""Delete Segment # noqa: E501
Delete an existing segment. Required Access Level: ModifyContacts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.segments_by_name_delete(name, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of your segment.
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['name'] = \
name
return self.call_with_http_info(**kwargs)
self.segments_by_name_delete = _Endpoint(
settings={
'response_type': None,
'auth': ['apikey'],
'endpoint_path': '/segments/{name}',
'operation_id': 'segments_by_name_delete',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'name',
],
'required': [
'name',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'name': (str, ),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__segments_by_name_delete)
def __segments_by_name_get(self, name, **kwargs):
"""Load Segment # noqa: E501
Returns details for the specified segment. Required Access Level: ViewContacts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.segments_by_name_get(name, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of the segment you want to load. Will load all contacts if the 'All Contacts' name has been provided
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:
Segment
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['name'] = \
name
return self.call_with_http_info(**kwargs)
self.segments_by_name_get = _Endpoint(settings={
'response_type': (Segment, ),
'auth': ['apikey'],
'endpoint_path': '/segments/{name}',
'operation_id': 'segments_by_name_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'name',
],
'required': [
'name',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'name': (str, ),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept':
['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__segments_by_name_get)
def __segments_by_name_put(self, name, segment_payload, **kwargs):
"""Update Segment # noqa: E501
Rename or change RULE for your segment. Required Access Level: ModifyContacts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.segments_by_name_put(name, segment_payload, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of your segment.
segment_payload (SegmentPayload):
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:
Segment
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['name'] = \
name
kwargs['segment_payload'] = \
segment_payload
return self.call_with_http_info(**kwargs)
self.segments_by_name_put = _Endpoint(settings={
'response_type': (Segment, ),
'auth': ['apikey'],
'endpoint_path': '/segments/{name}',
'operation_id': 'segments_by_name_put',
'http_method': 'PUT',
'servers': None,
},
params_map={
'all': [
'name',
'segment_payload',
],
'required': [
'name',
'segment_payload',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'name': (str, ),
'segment_payload':
(SegmentPayload, ),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
'segment_payload':
'body',
},
'collection_format_map': {}
},
headers_map={
'accept':
['application/json'],
'content_type':
['application/json']
},
api_client=api_client,
callable=__segments_by_name_put)
def __segments_get(self, **kwargs):
"""Load Segments # noqa: E501
Returns a list of all your available Segments. Required Access Level: ViewContacts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.segments_get(async_req=True)
>>> result = thread.get()
Keyword Args:
limit (int): Maximum number of returned items.. [optional]
offset (int): How many items should be returned ahead.. [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:
[Segment]
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.segments_get = _Endpoint(settings={
'response_type': ([Segment], ),
'auth': ['apikey'],
'endpoint_path': '/segments',
'operation_id': 'segments_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'limit',
'offset',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'limit': (int, ),
'offset': (int, ),
},
'attribute_map': {
'limit': 'limit',
'offset': 'offset',
},
'location_map': {
'limit': 'query',
'offset': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__segments_get)
def __segments_post(self, segment_payload, **kwargs):
"""Add Segment # noqa: E501
Add a new segment, based on specified RULE. Required Access Level: ModifyContacts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.segments_post(segment_payload, async_req=True)
>>> result = thread.get()
Args:
segment_payload (SegmentPayload):
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:
Segment
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['segment_payload'] = \
segment_payload
return self.call_with_http_info(**kwargs)
self.segments_post = _Endpoint(settings={
'response_type': (Segment, ),
'auth': ['apikey'],
'endpoint_path': '/segments',
'operation_id': 'segments_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'segment_payload',
],
'required': [
'segment_payload',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'segment_payload':
(SegmentPayload, ),
},
'attribute_map': {},
'location_map': {
'segment_payload': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type':
['application/json']
},
api_client=api_client,
callable=__segments_post)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __emails_by_msgid_view_get(self, msgid, **kwargs):
"""View Email # noqa: E501
Returns email details for viewing or rendering. Required Access Level: None # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.emails_by_msgid_view_get(msgid, async_req=True)
>>> result = thread.get()
Args:
msgid (str): Message identifier
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:
EmailData
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['msgid'] = \
msgid
return self.call_with_http_info(**kwargs)
self.emails_by_msgid_view_get = _Endpoint(
settings={
'response_type': (EmailData, ),
'auth': ['apikey'],
'endpoint_path': '/emails/{msgid}/view',
'operation_id': 'emails_by_msgid_view_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'msgid',
],
'required': [
'msgid',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'msgid': (str, ),
},
'attribute_map': {
'msgid': 'msgid',
},
'location_map': {
'msgid': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__emails_by_msgid_view_get)
def __emails_mergefile_post(self, merge_email_payload, **kwargs):
"""Send Bulk Emails CSV # noqa: E501
Send bulk merge email. Required Access Level: SendHttp # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.emails_mergefile_post(merge_email_payload, async_req=True)
>>> result = thread.get()
Args:
merge_email_payload (MergeEmailPayload): Email data
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:
EmailSend
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['merge_email_payload'] = \
merge_email_payload
return self.call_with_http_info(**kwargs)
self.emails_mergefile_post = _Endpoint(
settings={
'response_type': (EmailSend, ),
'auth': ['apikey'],
'endpoint_path': '/emails/mergefile',
'operation_id': 'emails_mergefile_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'merge_email_payload',
],
'required': [
'merge_email_payload',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'merge_email_payload': (MergeEmailPayload, ),
},
'attribute_map': {},
'location_map': {
'merge_email_payload': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__emails_mergefile_post)
def __emails_post(self, email_message_data, **kwargs):
"""Send Bulk Emails # noqa: E501
Send bulk merge email. Required Access Level: SendHttp # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.emails_post(email_message_data, async_req=True)
>>> result = thread.get()
Args:
email_message_data (EmailMessageData): Email data
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:
EmailSend
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['email_message_data'] = \
email_message_data
return self.call_with_http_info(**kwargs)
self.emails_post = _Endpoint(settings={
'response_type': (EmailSend, ),
'auth': ['apikey'],
'endpoint_path': '/emails',
'operation_id': 'emails_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'email_message_data',
],
'required': [
'email_message_data',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'email_message_data':
(EmailMessageData, ),
},
'attribute_map': {},
'location_map': {
'email_message_data': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__emails_post)
def __emails_transactional_post(self, email_transactional_message_data,
**kwargs):
"""Send Transactional Email # noqa: E501
Send transactional emails (recipients will be known to each other). Required Access Level: SendHttp # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.emails_transactional_post(email_transactional_message_data, async_req=True)
>>> result = thread.get()
Args:
email_transactional_message_data (EmailTransactionalMessageData): Email data
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:
EmailSend
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['email_transactional_message_data'] = \
email_transactional_message_data
return self.call_with_http_info(**kwargs)
self.emails_transactional_post = _Endpoint(
settings={
'response_type': (EmailSend, ),
'auth': ['apikey'],
'endpoint_path': '/emails/transactional',
'operation_id': 'emails_transactional_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'email_transactional_message_data',
],
'required': [
'email_transactional_message_data',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'email_transactional_message_data':
(EmailTransactionalMessageData, ),
},
'attribute_map': {},
'location_map': {
'email_transactional_message_data': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__emails_transactional_post)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __templates_by_name_delete(self, name, **kwargs):
"""Delete Template # noqa: E501
Delete template with the specified name. Required Access Level: ModifyTemplates # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.templates_by_name_delete(name, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of template.
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['name'] = \
name
return self.call_with_http_info(**kwargs)
self.templates_by_name_delete = _Endpoint(
settings={
'response_type': None,
'auth': ['apikey'],
'endpoint_path': '/templates/{name}',
'operation_id': 'templates_by_name_delete',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'name',
],
'required': [
'name',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'name': (str, ),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__templates_by_name_delete)
def __templates_by_name_get(self, name, **kwargs):
"""Load Template # noqa: E501
Load detailed information of the specified template. Required Access Level: ViewTemplates # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.templates_by_name_get(name, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of template.
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:
object
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['name'] = \
name
return self.call_with_http_info(**kwargs)
self.templates_by_name_get = _Endpoint(
settings={
'response_type': (object, ),
'auth': ['apikey'],
'endpoint_path': '/templates/{name}',
'operation_id': 'templates_by_name_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'name',
],
'required': [
'name',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'name': (str, ),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__templates_by_name_get)
def __templates_by_name_put(self, name, template_payload, **kwargs):
"""Update Template # noqa: E501
Update existing template, overwriting existing data. Required Access Level: ModifyTemplates # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.templates_by_name_put(name, template_payload, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of template.
template_payload (TemplatePayload):
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:
Template
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['name'] = \
name
kwargs['template_payload'] = \
template_payload
return self.call_with_http_info(**kwargs)
self.templates_by_name_put = _Endpoint(
settings={
'response_type': (Template, ),
'auth': ['apikey'],
'endpoint_path': '/templates/{name}',
'operation_id': 'templates_by_name_put',
'http_method': 'PUT',
'servers': None,
},
params_map={
'all': [
'name',
'template_payload',
],
'required': [
'name',
'template_payload',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'name': (str, ),
'template_payload': (TemplatePayload, ),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
'template_payload': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__templates_by_name_put)
def __templates_get(self, scope_type, **kwargs):
"""Load Templates # noqa: E501
Returns a list of templates for the specified type. Required Access Level: ViewTemplates # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.templates_get(scope_type, async_req=True)
>>> result = thread.get()
Args:
scope_type ([TemplateScope]): Return templates with specified scope only
Keyword Args:
template_types ([TemplateType]): Return templates with specified type only. [optional]
limit (int): Maximum number of returned items.. [optional]
offset (int): How many items should be returned ahead.. [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:
[Template]
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['scope_type'] = \
scope_type
return self.call_with_http_info(**kwargs)
self.templates_get = _Endpoint(settings={
'response_type': ([Template], ),
'auth': ['apikey'],
'endpoint_path': '/templates',
'operation_id': 'templates_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'scope_type',
'template_types',
'limit',
'offset',
],
'required': [
'scope_type',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'scope_type':
([TemplateScope], ),
'template_types':
([TemplateType], ),
'limit': (int, ),
'offset': (int, ),
},
'attribute_map': {
'scope_type': 'scopeType',
'template_types':
'templateTypes',
'limit': 'limit',
'offset': 'offset',
},
'location_map': {
'scope_type': 'query',
'template_types': 'query',
'limit': 'query',
'offset': 'query',
},
'collection_format_map': {
'scope_type': 'multi',
'template_types': 'multi',
}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__templates_get)
def __templates_post(self, template_payload, **kwargs):
"""Add Template # noqa: E501
Add a new Template. Required Access Level: ModifyTemplates # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.templates_post(template_payload, async_req=True)
>>> result = thread.get()
Args:
template_payload (TemplatePayload):
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:
object
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['template_payload'] = \
template_payload
return self.call_with_http_info(**kwargs)
self.templates_post = _Endpoint(settings={
'response_type': (object, ),
'auth': ['apikey'],
'endpoint_path': '/templates',
'operation_id': 'templates_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'template_payload',
],
'required': [
'template_payload',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'template_payload':
(TemplatePayload, ),
},
'attribute_map': {},
'location_map': {
'template_payload': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type':
['application/json']
},
api_client=api_client,
callable=__templates_post)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __inboundroute_by_id_delete(self, id, **kwargs):
"""Delete Route # noqa: E501
Deletes the Inbound Route. Required Access Level: ModifySettings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.inboundroute_by_id_delete(id, async_req=True)
>>> result = thread.get()
Args:
id (str):
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['id'] = \
id
return self.call_with_http_info(**kwargs)
self.inboundroute_by_id_delete = _Endpoint(
settings={
'response_type': None,
'auth': ['apikey'],
'endpoint_path': '/inboundroute/{id}',
'operation_id': 'inboundroute_by_id_delete',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'id',
],
'required': [
'id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'id': (str, ),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__inboundroute_by_id_delete)
def __inboundroute_by_id_get(self, id, **kwargs):
"""Get Route # noqa: E501
Load an Inbound Route. Required Access Level: ViewSettings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.inboundroute_by_id_get(id, async_req=True)
>>> result = thread.get()
Args:
id (str): ID number of your attachment
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:
InboundRoute
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['id'] = \
id
return self.call_with_http_info(**kwargs)
self.inboundroute_by_id_get = _Endpoint(
settings={
'response_type': (InboundRoute, ),
'auth': ['apikey'],
'endpoint_path': '/inboundroute/{id}',
'operation_id': 'inboundroute_by_id_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'id',
],
'required': [
'id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'id': (str, ),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__inboundroute_by_id_get)
def __inboundroute_by_id_put(self, id, inbound_payload, **kwargs):
"""Update Route # noqa: E501
Update the Inbound Route. Required Access Level: ModifySettings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.inboundroute_by_id_put(id, inbound_payload, async_req=True)
>>> result = thread.get()
Args:
id (str):
inbound_payload (InboundPayload):
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:
InboundRoute
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['id'] = \
id
kwargs['inbound_payload'] = \
inbound_payload
return self.call_with_http_info(**kwargs)
self.inboundroute_by_id_put = _Endpoint(
settings={
'response_type': (InboundRoute, ),
'auth': ['apikey'],
'endpoint_path': '/inboundroute/{id}',
'operation_id': 'inboundroute_by_id_put',
'http_method': 'PUT',
'servers': None,
},
params_map={
'all': [
'id',
'inbound_payload',
],
'required': [
'id',
'inbound_payload',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'id': (str, ),
'inbound_payload': (InboundPayload, ),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
'inbound_payload': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__inboundroute_by_id_put)
def __inboundroute_get(self, **kwargs):
"""Get Routes # noqa: E501
Get all your Inbound Routes. Required Access Level: ViewSettings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.inboundroute_get(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:
[InboundRoute]
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.inboundroute_get = _Endpoint(settings={
'response_type': ([InboundRoute], ),
'auth': ['apikey'],
'endpoint_path': '/inboundroute',
'operation_id': 'inboundroute_get',
'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=__inboundroute_get)
def __inboundroute_order_put(self, sort_order_item, **kwargs):
"""Update Sorting # noqa: E501
Required Access Level: ViewSettings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.inboundroute_order_put(sort_order_item, async_req=True)
>>> result = thread.get()
Args:
sort_order_item ([SortOrderItem]): Change the ordering of inbound routes for when matching the inbound
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:
[InboundRoute]
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['sort_order_item'] = \
sort_order_item
return self.call_with_http_info(**kwargs)
self.inboundroute_order_put = _Endpoint(
settings={
'response_type': ([InboundRoute], ),
'auth': ['apikey'],
'endpoint_path': '/inboundroute/order',
'operation_id': 'inboundroute_order_put',
'http_method': 'PUT',
'servers': None,
},
params_map={
'all': [
'sort_order_item',
],
'required': [
'sort_order_item',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'sort_order_item': ([SortOrderItem], ),
},
'attribute_map': {},
'location_map': {
'sort_order_item': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__inboundroute_order_put)
def __inboundroute_post(self, inbound_payload, **kwargs):
"""Create Route # noqa: E501
Create new Inbound Route. Required Access Level: ModifySettings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.inboundroute_post(inbound_payload, async_req=True)
>>> result = thread.get()
Args:
inbound_payload (InboundPayload):
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:
InboundRoute
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['inbound_payload'] = \
inbound_payload
return self.call_with_http_info(**kwargs)
self.inboundroute_post = _Endpoint(settings={
'response_type': (InboundRoute, ),
'auth': ['apikey'],
'endpoint_path': '/inboundroute',
'operation_id': 'inboundroute_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'inbound_payload',
],
'required': [
'inbound_payload',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'inbound_payload':
(InboundPayload, ),
},
'attribute_map': {},
'location_map': {
'inbound_payload': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type':
['application/json']
},
api_client=api_client,
callable=__inboundroute_post)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __campaigns_by_name_delete(self, name, **kwargs):
"""Delete Campaign # noqa: E501
Delete the specific campaign. This does not cancel in progress email, see Cancel In Progress. Required Access Level: ModifyCampaigns # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.campaigns_by_name_delete(name, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of Campaign to delete
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['name'] = \
name
return self.call_with_http_info(**kwargs)
self.campaigns_by_name_delete = _Endpoint(
settings={
'response_type': None,
'auth': ['apikey'],
'endpoint_path': '/campaigns/{name}',
'operation_id': 'campaigns_by_name_delete',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'name',
],
'required': [
'name',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'name': (str, ),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__campaigns_by_name_delete)
def __campaigns_by_name_get(self, name, **kwargs):
"""Load Campaign # noqa: E501
Returns the specified campaign details. Required Access Level: ViewCampaigns # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.campaigns_by_name_get(name, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of Campaign to 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:
Campaign
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['name'] = \
name
return self.call_with_http_info(**kwargs)
self.campaigns_by_name_get = _Endpoint(
settings={
'response_type': (Campaign, ),
'auth': ['apikey'],
'endpoint_path': '/campaigns/{name}',
'operation_id': 'campaigns_by_name_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'name',
],
'required': [
'name',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'name': (str, ),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__campaigns_by_name_get)
def __campaigns_by_name_put(self, name, campaign, **kwargs):
"""Update Campaign # noqa: E501
Updates a previously added campaign. Only Active and Paused campaigns can be updated. Required Access Level: ModifyCampaigns # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.campaigns_by_name_put(name, campaign, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of Campaign to update
campaign (Campaign): JSON representation of a campaign
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:
Campaign
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['name'] = \
name
kwargs['campaign'] = \
campaign
return self.call_with_http_info(**kwargs)
self.campaigns_by_name_put = _Endpoint(
settings={
'response_type': (Campaign, ),
'auth': ['apikey'],
'endpoint_path': '/campaigns/{name}',
'operation_id': 'campaigns_by_name_put',
'http_method': 'PUT',
'servers': None,
},
params_map={
'all': [
'name',
'campaign',
],
'required': [
'name',
'campaign',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'name': (str, ),
'campaign': (Campaign, ),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
'campaign': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__campaigns_by_name_put)
def __campaigns_get(self, **kwargs):
"""Load Campaigns # noqa: E501
Returns a list all of your campaigns. Limited to 1000 results. Required Access Level: ViewCampaigns # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.campaigns_get(async_req=True)
>>> result = thread.get()
Keyword Args:
search (str): Text fragment used for searching in Campaign name (using the 'contains' rule). [optional]
offset (int): How many items should be returned ahead.. [optional]
limit (int): Maximum number of returned items.. [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:
[Campaign]
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.campaigns_get = _Endpoint(settings={
'response_type': ([Campaign], ),
'auth': ['apikey'],
'endpoint_path': '/campaigns',
'operation_id': 'campaigns_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'search',
'offset',
'limit',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'search': (str, ),
'offset': (int, ),
'limit': (int, ),
},
'attribute_map': {
'search': 'search',
'offset': 'offset',
'limit': 'limit',
},
'location_map': {
'search': 'query',
'offset': 'query',
'limit': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__campaigns_get)
def __campaigns_post(self, campaign, **kwargs):
"""Add Campaign # noqa: E501
Add a campaign for processing. Required Access Level: ModifyCampaigns # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.campaigns_post(campaign, async_req=True)
>>> result = thread.get()
Args:
campaign (Campaign): JSON representation of a campaign
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:
Campaign
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['campaign'] = \
campaign
return self.call_with_http_info(**kwargs)
self.campaigns_post = _Endpoint(settings={
'response_type': (Campaign, ),
'auth': ['apikey'],
'endpoint_path': '/campaigns',
'operation_id': 'campaigns_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'campaign',
],
'required': [
'campaign',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'campaign': (Campaign, ),
},
'attribute_map': {},
'location_map': {
'campaign': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type':
['application/json']
},
api_client=api_client,
callable=__campaigns_post)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __verifications_by_email_delete(self, email, **kwargs):
"""Delete Email Verification Result # noqa: E501
Delete a result with given email if exists. Required Access Level: VerifyEmails # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.verifications_by_email_delete(email, async_req=True)
>>> result = thread.get()
Args:
email (str): Email address to verification
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['email'] = \
email
return self.call_with_http_info(**kwargs)
self.verifications_by_email_delete = _Endpoint(
settings={
'response_type': None,
'auth': ['apikey'],
'endpoint_path': '/verifications/{email}',
'operation_id': 'verifications_by_email_delete',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'email',
],
'required': [
'email',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'email': (str, ),
},
'attribute_map': {
'email': 'email',
},
'location_map': {
'email': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__verifications_by_email_delete)
def __verifications_by_email_get(self, email, **kwargs):
"""Get Email Verification Result # noqa: E501
Returns a result of verified email. Required Access Level: ViewEmailVerifications # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.verifications_by_email_get(email, async_req=True)
>>> result = thread.get()
Args:
email (str): Email address to view verification result of
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:
EmailValidationResult
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['email'] = \
email
return self.call_with_http_info(**kwargs)
self.verifications_by_email_get = _Endpoint(
settings={
'response_type': (EmailValidationResult, ),
'auth': ['apikey'],
'endpoint_path': '/verifications/{email}',
'operation_id': 'verifications_by_email_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'email',
],
'required': [
'email',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'email': (str, ),
},
'attribute_map': {
'email': 'email',
},
'location_map': {
'email': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__verifications_by_email_get)
def __verifications_by_email_post(self, email, **kwargs):
"""Verify Email # noqa: E501
Verify single email address and returns result of verification. Required Access Level: VerifyEmails # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.verifications_by_email_post(email, async_req=True)
>>> result = thread.get()
Args:
email (str): Email address to verify
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:
EmailValidationResult
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['email'] = \
email
return self.call_with_http_info(**kwargs)
self.verifications_by_email_post = _Endpoint(
settings={
'response_type': (EmailValidationResult, ),
'auth': ['apikey'],
'endpoint_path': '/verifications/{email}',
'operation_id': 'verifications_by_email_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'email',
],
'required': [
'email',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'email': (str, ),
},
'attribute_map': {
'email': 'email',
},
'location_map': {
'email': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__verifications_by_email_post)
def __verifications_files_by_id_delete(self, id, **kwargs):
"""Delete File Verification Result # noqa: E501
Delete Verification Results if they exist. Required Access Level: VerifyEmails # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.verifications_files_by_id_delete(id, async_req=True)
>>> result = thread.get()
Args:
id (str): ID of the exported file
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['id'] = \
id
return self.call_with_http_info(**kwargs)
self.verifications_files_by_id_delete = _Endpoint(
settings={
'response_type': None,
'auth': ['apikey'],
'endpoint_path': '/verifications/files/{id}',
'operation_id': 'verifications_files_by_id_delete',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'id',
],
'required': [
'id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'id': (str, ),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__verifications_files_by_id_delete)
def __verifications_files_by_id_result_download_get(
self, id, **kwargs):
"""Download File Verification Result # noqa: E501
Download verification results as a ZIP file. Required Access Level: VerifyEmails # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.verifications_files_by_id_result_download_get(id, async_req=True)
>>> result = thread.get()
Args:
id (str): Verification ID to download
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:
file_type
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['id'] = \
id
return self.call_with_http_info(**kwargs)
self.verifications_files_by_id_result_download_get = _Endpoint(
settings={
'response_type': (file_type, ),
'auth': ['apikey'],
'endpoint_path': '/verifications/files/{id}/result/download',
'operation_id':
'verifications_files_by_id_result_download_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'id',
],
'required': [
'id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'id': (str, ),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/*'],
'content_type': [],
},
api_client=api_client,
callable=__verifications_files_by_id_result_download_get)
def __verifications_files_by_id_result_get(self, id, **kwargs):
"""Get Detailed File Verification Result # noqa: E501
Returns status and results (if verified) of file with given ID. Required Access Level: ViewEmailVerifications # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.verifications_files_by_id_result_get(id, async_req=True)
>>> result = thread.get()
Args:
id (str): ID of the Verification to display status of
Keyword Args:
limit (int): Maximum number of returned email verification results. [optional]
offset (int): How many result items should be returned ahead. [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:
VerificationFileResultDetails
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['id'] = \
id
return self.call_with_http_info(**kwargs)
self.verifications_files_by_id_result_get = _Endpoint(
settings={
'response_type': (VerificationFileResultDetails, ),
'auth': ['apikey'],
'endpoint_path': '/verifications/files/{id}/result',
'operation_id': 'verifications_files_by_id_result_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'id',
'limit',
'offset',
],
'required': [
'id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'id': (str, ),
'limit': (int, ),
'offset': (int, ),
},
'attribute_map': {
'id': 'id',
'limit': 'limit',
'offset': 'offset',
},
'location_map': {
'id': 'path',
'limit': 'query',
'offset': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__verifications_files_by_id_result_get)
def __verifications_files_by_id_verification_post(self, id, **kwargs):
"""Start verification # noqa: E501
Start a verification of the previously uploaded file with emails. Required Access Level: VerifyEmails # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.verifications_files_by_id_verification_post(id, async_req=True)
>>> result = thread.get()
Args:
id (str): File ID to start verification
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['id'] = \
id
return self.call_with_http_info(**kwargs)
self.verifications_files_by_id_verification_post = _Endpoint(
settings={
'response_type': None,
'auth': ['apikey'],
'endpoint_path': '/verifications/files/{id}/verification',
'operation_id': 'verifications_files_by_id_verification_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'id',
],
'required': [
'id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'id': (str, ),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__verifications_files_by_id_verification_post)
def __verifications_files_post(self, **kwargs):
"""Upload File with Emails # noqa: E501
Uploads a CSV file with list of emails that can then be triggered for verification. An 'email' column is required. Required Access Level: VerifyEmails # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.verifications_files_post(async_req=True)
>>> result = thread.get()
Keyword Args:
file (file_type): [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:
VerificationFileResult
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.verifications_files_post = _Endpoint(
settings={
'response_type': (VerificationFileResult, ),
'auth': ['apikey'],
'endpoint_path': '/verifications/files',
'operation_id': 'verifications_files_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'file',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'file': (file_type, ),
},
'attribute_map': {
'file': 'file',
},
'location_map': {
'file': 'form',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['multipart/form-data']
},
api_client=api_client,
callable=__verifications_files_post)
def __verifications_files_result_get(self, **kwargs):
"""Get Files Verification Results # noqa: E501
Returns a list of uploaded files, their statuses and results. Required Access Level: ViewEmailVerifications # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.verifications_files_result_get(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:
[VerificationFileResult]
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.verifications_files_result_get = _Endpoint(
settings={
'response_type': ([VerificationFileResult], ),
'auth': ['apikey'],
'endpoint_path': '/verifications/files/result',
'operation_id': 'verifications_files_result_get',
'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=__verifications_files_result_get)
def __verifications_get(self, **kwargs):
"""Get Emails Verification Results # noqa: E501
Returns a results of all verified single emails. Required Access Level: ViewEmailVerifications # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.verifications_get(async_req=True)
>>> result = thread.get()
Keyword Args:
limit (int): Maximum number of returned items.. [optional]
offset (int): How many items should be returned ahead.. [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:
[EmailValidationResult]
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.verifications_get = _Endpoint(settings={
'response_type': ([EmailValidationResult], ),
'auth': ['apikey'],
'endpoint_path':
'/verifications',
'operation_id':
'verifications_get',
'http_method':
'GET',
'servers':
None,
},
params_map={
'all': [
'limit',
'offset',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'limit': (int, ),
'offset': (int, ),
},
'attribute_map': {
'limit': 'limit',
'offset': 'offset',
},
'location_map': {
'limit': 'query',
'offset': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__verifications_get)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __security_apikeys_by_name_delete(
self,
name,
**kwargs
):
"""Delete ApiKey # noqa: E501
Delete your existing ApiKey. Required Access Level: Security # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.security_apikeys_by_name_delete(name, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of the ApiKey
Keyword Args:
subaccount (str): Email of the subaccount of which ApiKey should be deleted. [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:
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['name'] = \
name
return self.call_with_http_info(**kwargs)
self.security_apikeys_by_name_delete = _Endpoint(
settings={
'response_type': None,
'auth': [
'apikey'
],
'endpoint_path': '/security/apikeys/{name}',
'operation_id': 'security_apikeys_by_name_delete',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'name',
'subaccount',
],
'required': [
'name',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'name':
(str,),
'subaccount':
(str,),
},
'attribute_map': {
'name': 'name',
'subaccount': 'subaccount',
},
'location_map': {
'name': 'path',
'subaccount': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__security_apikeys_by_name_delete
)
def __security_apikeys_by_name_get(
self,
name,
**kwargs
):
"""Load ApiKey # noqa: E501
Load your existing ApiKey info. Required Access Level: Security # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.security_apikeys_by_name_get(name, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of the ApiKey
Keyword Args:
subaccount (str): Email of the subaccount of which ApiKey should be loaded. [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:
ApiKey
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['name'] = \
name
return self.call_with_http_info(**kwargs)
self.security_apikeys_by_name_get = _Endpoint(
settings={
'response_type': (ApiKey,),
'auth': [
'apikey'
],
'endpoint_path': '/security/apikeys/{name}',
'operation_id': 'security_apikeys_by_name_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'name',
'subaccount',
],
'required': [
'name',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'name':
(str,),
'subaccount':
(str,),
},
'attribute_map': {
'name': 'name',
'subaccount': 'subaccount',
},
'location_map': {
'name': 'path',
'subaccount': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__security_apikeys_by_name_get
)
def __security_apikeys_by_name_put(
self,
name,
api_key_payload,
**kwargs
):
"""Update ApiKey # noqa: E501
Update your existing ApiKey. Required Access Level: Security # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.security_apikeys_by_name_put(name, api_key_payload, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of the ApiKey
api_key_payload (ApiKeyPayload):
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:
ApiKey
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['name'] = \
name
kwargs['api_key_payload'] = \
api_key_payload
return self.call_with_http_info(**kwargs)
self.security_apikeys_by_name_put = _Endpoint(
settings={
'response_type': (ApiKey,),
'auth': [
'apikey'
],
'endpoint_path': '/security/apikeys/{name}',
'operation_id': 'security_apikeys_by_name_put',
'http_method': 'PUT',
'servers': None,
},
params_map={
'all': [
'name',
'api_key_payload',
],
'required': [
'name',
'api_key_payload',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'name':
(str,),
'api_key_payload':
(ApiKeyPayload,),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
'api_key_payload': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/json'
]
},
api_client=api_client,
callable=__security_apikeys_by_name_put
)
def __security_apikeys_get(
self,
**kwargs
):
"""List ApiKeys # noqa: E501
List all your existing ApiKeys. Required Access Level: Security # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.security_apikeys_get(async_req=True)
>>> result = thread.get()
Keyword Args:
subaccount (str): Email of the subaccount of which ApiKeys should be loaded. [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:
[ApiKey]
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.security_apikeys_get = _Endpoint(
settings={
'response_type': ([ApiKey],),
'auth': [
'apikey'
],
'endpoint_path': '/security/apikeys',
'operation_id': 'security_apikeys_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'subaccount',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'subaccount':
(str,),
},
'attribute_map': {
'subaccount': 'subaccount',
},
'location_map': {
'subaccount': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__security_apikeys_get
)
def __security_apikeys_post(
self,
api_key_payload,
**kwargs
):
"""Add ApiKey # noqa: E501
Add a new ApiKey. Required Access Level: Security # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.security_apikeys_post(api_key_payload, async_req=True)
>>> result = thread.get()
Args:
api_key_payload (ApiKeyPayload):
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:
NewApiKey
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['api_key_payload'] = \
api_key_payload
return self.call_with_http_info(**kwargs)
self.security_apikeys_post = _Endpoint(
settings={
'response_type': (NewApiKey,),
'auth': [
'apikey'
],
'endpoint_path': '/security/apikeys',
'operation_id': 'security_apikeys_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'api_key_payload',
],
'required': [
'api_key_payload',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'api_key_payload':
(ApiKeyPayload,),
},
'attribute_map': {
},
'location_map': {
'api_key_payload': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/json'
]
},
api_client=api_client,
callable=__security_apikeys_post
)
def __security_smtp_by_name_delete(
self,
name,
**kwargs
):
"""Delete SMTP Credential # noqa: E501
Delete your existing SMTP Credentials. Required Access Level: Security # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.security_smtp_by_name_delete(name, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of the SMTP Credential
Keyword Args:
subaccount (str): Email of the subaccount of which credential should be deleted. [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:
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['name'] = \
name
return self.call_with_http_info(**kwargs)
self.security_smtp_by_name_delete = _Endpoint(
settings={
'response_type': None,
'auth': [
'apikey'
],
'endpoint_path': '/security/smtp/{name}',
'operation_id': 'security_smtp_by_name_delete',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'name',
'subaccount',
],
'required': [
'name',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'name':
(str,),
'subaccount':
(str,),
},
'attribute_map': {
'name': 'name',
'subaccount': 'subaccount',
},
'location_map': {
'name': 'path',
'subaccount': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__security_smtp_by_name_delete
)
def __security_smtp_by_name_get(
self,
name,
**kwargs
):
"""Load SMTP Credential # noqa: E501
Load your existing SMTP Credential info. Required Access Level: Security # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.security_smtp_by_name_get(name, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of the SMTP Credential
Keyword Args:
subaccount (str): Email of the subaccount of which credential should be loaded. [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:
SmtpCredentials
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['name'] = \
name
return self.call_with_http_info(**kwargs)
self.security_smtp_by_name_get = _Endpoint(
settings={
'response_type': (SmtpCredentials,),
'auth': [
'apikey'
],
'endpoint_path': '/security/smtp/{name}',
'operation_id': 'security_smtp_by_name_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'name',
'subaccount',
],
'required': [
'name',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'name':
(str,),
'subaccount':
(str,),
},
'attribute_map': {
'name': 'name',
'subaccount': 'subaccount',
},
'location_map': {
'name': 'path',
'subaccount': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__security_smtp_by_name_get
)
def __security_smtp_by_name_put(
self,
name,
smtp_credentials_payload,
**kwargs
):
"""Update SMTP Credential # noqa: E501
Update your existing SMTP Credentials. Required Access Level: Security # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.security_smtp_by_name_put(name, smtp_credentials_payload, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of the SMTP Credential
smtp_credentials_payload (SmtpCredentialsPayload):
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:
SmtpCredentials
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['name'] = \
name
kwargs['smtp_credentials_payload'] = \
smtp_credentials_payload
return self.call_with_http_info(**kwargs)
self.security_smtp_by_name_put = _Endpoint(
settings={
'response_type': (SmtpCredentials,),
'auth': [
'apikey'
],
'endpoint_path': '/security/smtp/{name}',
'operation_id': 'security_smtp_by_name_put',
'http_method': 'PUT',
'servers': None,
},
params_map={
'all': [
'name',
'smtp_credentials_payload',
],
'required': [
'name',
'smtp_credentials_payload',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'name':
(str,),
'smtp_credentials_payload':
(SmtpCredentialsPayload,),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
'smtp_credentials_payload': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/json'
]
},
api_client=api_client,
callable=__security_smtp_by_name_put
)
def __security_smtp_get(
self,
**kwargs
):
"""List SMTP Credentials # noqa: E501
List all your existing SMTP Credentials. Required Access Level: Security # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.security_smtp_get(async_req=True)
>>> result = thread.get()
Keyword Args:
subaccount (str): Email of the subaccount of which credentials should be listed. [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:
[SmtpCredentials]
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.security_smtp_get = _Endpoint(
settings={
'response_type': ([SmtpCredentials],),
'auth': [
'apikey'
],
'endpoint_path': '/security/smtp',
'operation_id': 'security_smtp_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'subaccount',
],
'required': [],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'subaccount':
(str,),
},
'attribute_map': {
'subaccount': 'subaccount',
},
'location_map': {
'subaccount': 'query',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [],
},
api_client=api_client,
callable=__security_smtp_get
)
def __security_smtp_post(
self,
smtp_credentials_payload,
**kwargs
):
"""Add SMTP Credential # noqa: E501
Add new SMTP Credential. Required Access Level: Security # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.security_smtp_post(smtp_credentials_payload, async_req=True)
>>> result = thread.get()
Args:
smtp_credentials_payload (SmtpCredentialsPayload):
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:
NewSmtpCredentials
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['smtp_credentials_payload'] = \
smtp_credentials_payload
return self.call_with_http_info(**kwargs)
self.security_smtp_post = _Endpoint(
settings={
'response_type': (NewSmtpCredentials,),
'auth': [
'apikey'
],
'endpoint_path': '/security/smtp',
'operation_id': 'security_smtp_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'smtp_credentials_payload',
],
'required': [
'smtp_credentials_payload',
],
'nullable': [
],
'enum': [
],
'validation': [
]
},
root_map={
'validations': {
},
'allowed_values': {
},
'openapi_types': {
'smtp_credentials_payload':
(SmtpCredentialsPayload,),
},
'attribute_map': {
},
'location_map': {
'smtp_credentials_payload': 'body',
},
'collection_format_map': {
}
},
headers_map={
'accept': [
'application/json'
],
'content_type': [
'application/json'
]
},
api_client=api_client,
callable=__security_smtp_post
)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __statistics_campaigns_by_name_get(self, name, **kwargs):
"""Load Campaign Stats # noqa: E501
Retrieve stats of an existing campaign. Required Access Level: ViewChannels # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.statistics_campaigns_by_name_get(name, async_req=True)
>>> result = thread.get()
Args:
name (str): The name of the campaign to 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:
ChannelLogStatusSummary
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['name'] = \
name
return self.call_with_http_info(**kwargs)
self.statistics_campaigns_by_name_get = _Endpoint(
settings={
'response_type': (ChannelLogStatusSummary, ),
'auth': ['apikey'],
'endpoint_path': '/statistics/campaigns/{name}',
'operation_id': 'statistics_campaigns_by_name_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'name',
],
'required': [
'name',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'name': (str, ),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__statistics_campaigns_by_name_get)
def __statistics_campaigns_get(self, **kwargs):
"""Load Campaigns Stats # noqa: E501
Returns a list of your Campaigns' stats. Required Access Level: ViewChannels # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.statistics_campaigns_get(async_req=True)
>>> result = thread.get()
Keyword Args:
limit (int): Maximum number of returned items.. [optional]
offset (int): How many items should be returned ahead.. [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:
[ChannelLogStatusSummary]
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.statistics_campaigns_get = _Endpoint(
settings={
'response_type': ([ChannelLogStatusSummary], ),
'auth': ['apikey'],
'endpoint_path': '/statistics/campaigns',
'operation_id': 'statistics_campaigns_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'limit',
'offset',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'limit': (int, ),
'offset': (int, ),
},
'attribute_map': {
'limit': 'limit',
'offset': 'offset',
},
'location_map': {
'limit': 'query',
'offset': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__statistics_campaigns_get)
def __statistics_channels_by_name_get(self, name, **kwargs):
"""Load Channel Stats # noqa: E501
Retrieve an existing channel stats. Required Access Level: ViewChannels # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.statistics_channels_by_name_get(name, async_req=True)
>>> result = thread.get()
Args:
name (str): The name of the channel to 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:
ChannelLogStatusSummary
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['name'] = \
name
return self.call_with_http_info(**kwargs)
self.statistics_channels_by_name_get = _Endpoint(
settings={
'response_type': (ChannelLogStatusSummary, ),
'auth': ['apikey'],
'endpoint_path': '/statistics/channels/{name}',
'operation_id': 'statistics_channels_by_name_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'name',
],
'required': [
'name',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'name': (str, ),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__statistics_channels_by_name_get)
def __statistics_channels_get(self, **kwargs):
"""Load Channels Stats # noqa: E501
Returns a list of your Channels' stats. Required Access Level: ViewChannels # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.statistics_channels_get(async_req=True)
>>> result = thread.get()
Keyword Args:
limit (int): Maximum number of returned items.. [optional]
offset (int): How many items should be returned ahead.. [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:
[ChannelLogStatusSummary]
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.statistics_channels_get = _Endpoint(
settings={
'response_type': ([ChannelLogStatusSummary], ),
'auth': ['apikey'],
'endpoint_path': '/statistics/channels',
'operation_id': 'statistics_channels_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'limit',
'offset',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'limit': (int, ),
'offset': (int, ),
},
'attribute_map': {
'limit': 'limit',
'offset': 'offset',
},
'location_map': {
'limit': 'query',
'offset': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__statistics_channels_get)
def __statistics_get(self, _from, **kwargs):
"""Load Statistics # noqa: E501
Returns basic statistics. Required Access Level: ViewReports # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.statistics_get(_from, async_req=True)
>>> result = thread.get()
Args:
_from (datetime): Starting date for search in YYYY-MM-DDThh:mm:ss format.
Keyword Args:
to (datetime, none_type): Ending date for search in YYYY-MM-DDThh:mm:ss format.. [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:
LogStatusSummary
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['_from'] = \
_from
return self.call_with_http_info(**kwargs)
self.statistics_get = _Endpoint(settings={
'response_type': (LogStatusSummary, ),
'auth': ['apikey'],
'endpoint_path': '/statistics',
'operation_id': 'statistics_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'_from',
'to',
],
'required': [
'_from',
],
'nullable': [
'to',
],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'_from': (datetime, ),
'to': (
datetime,
none_type,
),
},
'attribute_map': {
'_from': 'from',
'to': 'to',
},
'location_map': {
'_from': 'query',
'to': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__statistics_get)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __files_by_name_delete(self, name, **kwargs):
"""Delete File # noqa: E501
Permanently deletes the file from your Account. Required Access Level: ModifyFiles # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.files_by_name_delete(name, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of your file including extension.
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['name'] = \
name
return self.call_with_http_info(**kwargs)
self.files_by_name_delete = _Endpoint(settings={
'response_type': None,
'auth': ['apikey'],
'endpoint_path': '/files/{name}',
'operation_id': 'files_by_name_delete',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'name',
],
'required': [
'name',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'name': (str, ),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__files_by_name_delete)
def __files_by_name_get(self, name, **kwargs):
"""Download File # noqa: E501
Gets content of the specified File. Required Access Level: ViewFiles # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.files_by_name_get(name, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of your file including extension.
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:
file_type
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['name'] = \
name
return self.call_with_http_info(**kwargs)
self.files_by_name_get = _Endpoint(settings={
'response_type': (file_type, ),
'auth': ['apikey'],
'endpoint_path': '/files/{name}',
'operation_id': 'files_by_name_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'name',
],
'required': [
'name',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'name': (str, ),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/*'],
'content_type': [],
},
api_client=api_client,
callable=__files_by_name_get)
def __files_by_name_info_get(self, name, **kwargs):
"""Load File Details # noqa: E501
Returns the specified File's details. Required Access Level: ViewFiles # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.files_by_name_info_get(name, async_req=True)
>>> result = thread.get()
Args:
name (str): Name of your file including extension.
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:
FileInfo
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['name'] = \
name
return self.call_with_http_info(**kwargs)
self.files_by_name_info_get = _Endpoint(
settings={
'response_type': (FileInfo, ),
'auth': ['apikey'],
'endpoint_path': '/files/{name}/info',
'operation_id': 'files_by_name_info_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'name',
],
'required': [
'name',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'name': (str, ),
},
'attribute_map': {
'name': 'name',
},
'location_map': {
'name': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__files_by_name_info_get)
def __files_get(self, **kwargs):
"""List Files # noqa: E501
Returns a list of all your available files. Required Access Level: ViewFiles # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.files_get(async_req=True)
>>> result = thread.get()
Keyword Args:
limit (int): Maximum number of returned items.. [optional]
offset (int): How many items should be returned ahead.. [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:
[FileInfo]
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.files_get = _Endpoint(settings={
'response_type': ([FileInfo], ),
'auth': ['apikey'],
'endpoint_path': '/files',
'operation_id': 'files_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'limit',
'offset',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'limit': (int, ),
'offset': (int, ),
},
'attribute_map': {
'limit': 'limit',
'offset': 'offset',
},
'location_map': {
'limit': 'query',
'offset': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__files_get)
def __files_post(self, file_payload, **kwargs):
"""Upload File # noqa: E501
Uploads selected file to the server. Required Access Level: ModifyFiles # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.files_post(file_payload, async_req=True)
>>> result = thread.get()
Args:
file_payload (FilePayload):
Keyword Args:
expires_after_days (int, none_type): After how many days should the file be deleted.. [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:
FileInfo
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['file_payload'] = \
file_payload
return self.call_with_http_info(**kwargs)
self.files_post = _Endpoint(settings={
'response_type': (FileInfo, ),
'auth': ['apikey'],
'endpoint_path': '/files',
'operation_id': 'files_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'file_payload',
'expires_after_days',
],
'required': [
'file_payload',
],
'nullable': [
'expires_after_days',
],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'file_payload': (FilePayload, ),
'expires_after_days': (
int,
none_type,
),
},
'attribute_map': {
'expires_after_days':
'expiresAfterDays',
},
'location_map': {
'file_payload': 'body',
'expires_after_days': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__files_post)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __contacts_by_email_delete(self, email, **kwargs):
"""Delete Contact # noqa: E501
Deletes the provided contact. Required Access Level: ModifyContacts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.contacts_by_email_delete(email, async_req=True)
>>> result = thread.get()
Args:
email (str): Proper email address.
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['email'] = \
email
return self.call_with_http_info(**kwargs)
self.contacts_by_email_delete = _Endpoint(
settings={
'response_type': None,
'auth': ['apikey'],
'endpoint_path': '/contacts/{email}',
'operation_id': 'contacts_by_email_delete',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'email',
],
'required': [
'email',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'email': (str, ),
},
'attribute_map': {
'email': 'email',
},
'location_map': {
'email': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__contacts_by_email_delete)
def __contacts_by_email_get(self, email, **kwargs):
"""Load Contact # noqa: E501
Load detailed contact information for specified email. Required Access Level: ViewContacts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.contacts_by_email_get(email, async_req=True)
>>> result = thread.get()
Args:
email (str): Proper email address.
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:
Contact
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['email'] = \
email
return self.call_with_http_info(**kwargs)
self.contacts_by_email_get = _Endpoint(
settings={
'response_type': (Contact, ),
'auth': ['apikey'],
'endpoint_path': '/contacts/{email}',
'operation_id': 'contacts_by_email_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'email',
],
'required': [
'email',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'email': (str, ),
},
'attribute_map': {
'email': 'email',
},
'location_map': {
'email': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__contacts_by_email_get)
def __contacts_by_email_history_get(self, email, **kwargs):
"""Load History # noqa: E501
Returns detailed history of specified Contact. Required Access Level: ViewContacts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.contacts_by_email_history_get(email, async_req=True)
>>> result = thread.get()
Args:
email (str): Proper email address.
Keyword Args:
limit (int): Maximum number of returned items.. [optional]
offset (int): How many items should be returned ahead.. [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:
[ContactHistory]
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['email'] = \
email
return self.call_with_http_info(**kwargs)
self.contacts_by_email_history_get = _Endpoint(
settings={
'response_type': ([ContactHistory], ),
'auth': ['apikey'],
'endpoint_path': '/contacts/{email}/history',
'operation_id': 'contacts_by_email_history_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'email',
'limit',
'offset',
],
'required': [
'email',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'email': (str, ),
'limit': (int, ),
'offset': (int, ),
},
'attribute_map': {
'email': 'email',
'limit': 'limit',
'offset': 'offset',
},
'location_map': {
'email': 'path',
'limit': 'query',
'offset': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__contacts_by_email_history_get)
def __contacts_by_email_put(self, email, contact_update_payload,
**kwargs):
"""Update Contact # noqa: E501
Update selected contact. Omitted contact's fields will not be changed. Required Access Level: ModifyContacts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.contacts_by_email_put(email, contact_update_payload, async_req=True)
>>> result = thread.get()
Args:
email (str): Proper email address.
contact_update_payload (ContactUpdatePayload):
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:
Contact
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['email'] = \
email
kwargs['contact_update_payload'] = \
contact_update_payload
return self.call_with_http_info(**kwargs)
self.contacts_by_email_put = _Endpoint(
settings={
'response_type': (Contact, ),
'auth': ['apikey'],
'endpoint_path': '/contacts/{email}',
'operation_id': 'contacts_by_email_put',
'http_method': 'PUT',
'servers': None,
},
params_map={
'all': [
'email',
'contact_update_payload',
],
'required': [
'email',
'contact_update_payload',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'email': (str, ),
'contact_update_payload': (ContactUpdatePayload, ),
},
'attribute_map': {
'email': 'email',
},
'location_map': {
'email': 'path',
'contact_update_payload': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__contacts_by_email_put)
def __contacts_delete_post(self, emails_payload, **kwargs):
"""Delete Contacts Bulk # noqa: E501
Deletes provided contacts in bulk. Required Access Level: ModifyContacts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.contacts_delete_post(emails_payload, async_req=True)
>>> result = thread.get()
Args:
emails_payload (EmailsPayload): Provide either rule or a list of emails, not both.
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['emails_payload'] = \
emails_payload
return self.call_with_http_info(**kwargs)
self.contacts_delete_post = _Endpoint(settings={
'response_type': None,
'auth': ['apikey'],
'endpoint_path': '/contacts/delete',
'operation_id': 'contacts_delete_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'emails_payload',
],
'required': [
'emails_payload',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'emails_payload':
(EmailsPayload, ),
},
'attribute_map': {},
'location_map': {
'emails_payload': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type':
['application/json']
},
api_client=api_client,
callable=__contacts_delete_post)
def __contacts_export_by_id_status_get(self, id, **kwargs):
"""Check Export Status # noqa: E501
Check the current status of the export. Required Access Level: Export # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.contacts_export_by_id_status_get(id, async_req=True)
>>> result = thread.get()
Args:
id (str): ID of the exported file
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:
ExportStatus
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['id'] = \
id
return self.call_with_http_info(**kwargs)
self.contacts_export_by_id_status_get = _Endpoint(
settings={
'response_type': (ExportStatus, ),
'auth': ['apikey'],
'endpoint_path': '/contacts/export/{id}/status',
'operation_id': 'contacts_export_by_id_status_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'id',
],
'required': [
'id',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'id': (str, ),
},
'attribute_map': {
'id': 'id',
},
'location_map': {
'id': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__contacts_export_by_id_status_get)
def __contacts_export_post(self, **kwargs):
"""Export Contacts # noqa: E501
Request an Export of specified Contacts. Required Access Level: Export # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.contacts_export_post(async_req=True)
>>> result = thread.get()
Keyword Args:
file_format (object): Format of the exported file. [optional]
rule (str): Query used for filtering.. [optional]
emails ([str]): Comma delimited list of contact emails. [optional]
compression_format (object): FileResponse compression format. None or Zip.. [optional]
file_name (str): Name of your file including extension.. [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:
ExportLink
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.contacts_export_post = _Endpoint(settings={
'response_type': (ExportLink, ),
'auth': ['apikey'],
'endpoint_path': '/contacts/export',
'operation_id': 'contacts_export_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'file_format',
'rule',
'emails',
'compression_format',
'file_name',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'file_format':
(object, ),
'rule': (str, ),
'emails': ([str], ),
'compression_format':
(object, ),
'file_name': (str, ),
},
'attribute_map': {
'file_format':
'fileFormat',
'rule': 'rule',
'emails': 'emails',
'compression_format':
'compressionFormat',
'file_name': 'fileName',
},
'location_map': {
'file_format': 'query',
'rule': 'query',
'emails': 'query',
'compression_format':
'query',
'file_name': 'query',
},
'collection_format_map': {
'emails': 'multi',
}
},
headers_map={
'accept':
['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__contacts_export_post)
def __contacts_get(self, **kwargs):
"""Load Contacts # noqa: E501
Returns a list of contacts. Required Access Level: ViewContacts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.contacts_get(async_req=True)
>>> result = thread.get()
Keyword Args:
limit (int): Maximum number of returned items.. [optional]
offset (int): How many items should be returned ahead.. [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:
[Contact]
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.contacts_get = _Endpoint(settings={
'response_type': ([Contact], ),
'auth': ['apikey'],
'endpoint_path': '/contacts',
'operation_id': 'contacts_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'limit',
'offset',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'limit': (int, ),
'offset': (int, ),
},
'attribute_map': {
'limit': 'limit',
'offset': 'offset',
},
'location_map': {
'limit': 'query',
'offset': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__contacts_get)
def __contacts_import_post(self, **kwargs):
"""Upload Contacts # noqa: E501
Upload contacts from a file. Required Access Level: ModifyContacts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.contacts_import_post(async_req=True)
>>> result = thread.get()
Keyword Args:
list_name (str): Name of an existing list to add these contacts to. [optional]
encoding_name (str): In what encoding the file is uploaded. [optional]
file (file_type): [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:
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')
return self.call_with_http_info(**kwargs)
self.contacts_import_post = _Endpoint(settings={
'response_type': None,
'auth': ['apikey'],
'endpoint_path': '/contacts/import',
'operation_id': 'contacts_import_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'list_name',
'encoding_name',
'file',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'list_name': (str, ),
'encoding_name': (str, ),
'file': (file_type, ),
},
'attribute_map': {
'list_name': 'listName',
'encoding_name':
'encodingName',
'file': 'file',
},
'location_map': {
'list_name': 'query',
'encoding_name': 'query',
'file': 'form',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type':
['multipart/form-data']
},
api_client=api_client,
callable=__contacts_import_post)
def __contacts_post(self, contact_payload, **kwargs):
"""Add Contact # noqa: E501
Add new Contacts to your Lists. Up to 1000 can be added (for more please refer to the import request). Required Access Level: ModifyContacts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.contacts_post(contact_payload, async_req=True)
>>> result = thread.get()
Args:
contact_payload ([ContactPayload]):
Keyword Args:
listnames ([str]): Names of lists to which the uploaded contacts should be added to. [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:
[Contact]
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['contact_payload'] = \
contact_payload
return self.call_with_http_info(**kwargs)
self.contacts_post = _Endpoint(settings={
'response_type': ([Contact], ),
'auth': ['apikey'],
'endpoint_path': '/contacts',
'operation_id': 'contacts_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'contact_payload',
'listnames',
],
'required': [
'contact_payload',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'contact_payload':
([ContactPayload], ),
'listnames': ([str], ),
},
'attribute_map': {
'listnames': 'listnames',
},
'location_map': {
'contact_payload': 'body',
'listnames': 'query',
},
'collection_format_map': {
'listnames': 'multi',
}
},
headers_map={
'accept': ['application/json'],
'content_type':
['application/json']
},
api_client=api_client,
callable=__contacts_post)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __subaccounts_by_email_credits_patch(
self, email, subaccount_email_credits_payload, **kwargs):
"""Add, Subtract Email Credits # noqa: E501
Update email credits of a subaccount by the given amount. Required Access Level: ModifySubAccounts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.subaccounts_by_email_credits_patch(email, subaccount_email_credits_payload, async_req=True)
>>> result = thread.get()
Args:
email (str): Email address of Sub-Account
subaccount_email_credits_payload (SubaccountEmailCreditsPayload): Amount of email credits to add or subtract from the current SubAccount email credits pool (positive or negative value)
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['email'] = \
email
kwargs['subaccount_email_credits_payload'] = \
subaccount_email_credits_payload
return self.call_with_http_info(**kwargs)
self.subaccounts_by_email_credits_patch = _Endpoint(
settings={
'response_type': None,
'auth': ['apikey'],
'endpoint_path': '/subaccounts/{email}/credits',
'operation_id': 'subaccounts_by_email_credits_patch',
'http_method': 'PATCH',
'servers': None,
},
params_map={
'all': [
'email',
'subaccount_email_credits_payload',
],
'required': [
'email',
'subaccount_email_credits_payload',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'email': (str, ),
'subaccount_email_credits_payload':
(SubaccountEmailCreditsPayload, ),
},
'attribute_map': {
'email': 'email',
},
'location_map': {
'email': 'path',
'subaccount_email_credits_payload': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': ['application/json']
},
api_client=api_client,
callable=__subaccounts_by_email_credits_patch)
def __subaccounts_by_email_delete(self, email, **kwargs):
"""Delete SubAccount # noqa: E501
Deletes specified SubAccount. An email will be sent to confirm this change. Required Access Level: ModifySubAccounts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.subaccounts_by_email_delete(email, async_req=True)
>>> result = thread.get()
Args:
email (str): Email address of Sub-Account
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['email'] = \
email
return self.call_with_http_info(**kwargs)
self.subaccounts_by_email_delete = _Endpoint(
settings={
'response_type': None,
'auth': ['apikey'],
'endpoint_path': '/subaccounts/{email}',
'operation_id': 'subaccounts_by_email_delete',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'email',
],
'required': [
'email',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'email': (str, ),
},
'attribute_map': {
'email': 'email',
},
'location_map': {
'email': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': [],
'content_type': [],
},
api_client=api_client,
callable=__subaccounts_by_email_delete)
def __subaccounts_by_email_get(self, email, **kwargs):
"""Load SubAccount # noqa: E501
Returns details for the specified SubAccount. Required Access Level: ViewSubAccounts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.subaccounts_by_email_get(email, async_req=True)
>>> result = thread.get()
Args:
email (str): Email address of Sub-Account
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:
SubAccountInfo
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['email'] = \
email
return self.call_with_http_info(**kwargs)
self.subaccounts_by_email_get = _Endpoint(
settings={
'response_type': (SubAccountInfo, ),
'auth': ['apikey'],
'endpoint_path': '/subaccounts/{email}',
'operation_id': 'subaccounts_by_email_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'email',
],
'required': [
'email',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'email': (str, ),
},
'attribute_map': {
'email': 'email',
},
'location_map': {
'email': 'path',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__subaccounts_by_email_get)
def __subaccounts_by_email_settings_email_put(
self, email, subaccount_email_settings, **kwargs):
"""Update SubAccount Email Settings # noqa: E501
Update SubAccount email settings. Required Access Level: ModifySubAccounts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.subaccounts_by_email_settings_email_put(email, subaccount_email_settings, async_req=True)
>>> result = thread.get()
Args:
email (str):
subaccount_email_settings (SubaccountEmailSettings): Updated Email Settings
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:
SubaccountEmailSettings
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['email'] = \
email
kwargs['subaccount_email_settings'] = \
subaccount_email_settings
return self.call_with_http_info(**kwargs)
self.subaccounts_by_email_settings_email_put = _Endpoint(
settings={
'response_type': (SubaccountEmailSettings, ),
'auth': ['apikey'],
'endpoint_path': '/subaccounts/{email}/settings/email',
'operation_id': 'subaccounts_by_email_settings_email_put',
'http_method': 'PUT',
'servers': None,
},
params_map={
'all': [
'email',
'subaccount_email_settings',
],
'required': [
'email',
'subaccount_email_settings',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'email': (str, ),
'subaccount_email_settings': (SubaccountEmailSettings, ),
},
'attribute_map': {
'email': 'email',
},
'location_map': {
'email': 'path',
'subaccount_email_settings': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__subaccounts_by_email_settings_email_put)
def __subaccounts_get(self, **kwargs):
"""Load SubAccounts # noqa: E501
Returns a list of all your SubAccounts. Required Access Level: ViewSubAccounts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.subaccounts_get(async_req=True)
>>> result = thread.get()
Keyword Args:
limit (int): Maximum number of returned items.. [optional]
offset (int): How many items should be returned ahead.. [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:
[SubAccountInfo]
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.subaccounts_get = _Endpoint(settings={
'response_type': ([SubAccountInfo], ),
'auth': ['apikey'],
'endpoint_path': '/subaccounts',
'operation_id': 'subaccounts_get',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'limit',
'offset',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'limit': (int, ),
'offset': (int, ),
},
'attribute_map': {
'limit': 'limit',
'offset': 'offset',
},
'location_map': {
'limit': 'query',
'offset': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__subaccounts_get)
def __subaccounts_post(self, subaccount_payload, **kwargs):
"""Add SubAccount # noqa: E501
Add a new SubAccount to your Account. To receive an access token for this SubAccount, make a POST security/apikeys request using the 'subaccount' parameter. Required Access Level: ModifySubAccounts # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.subaccounts_post(subaccount_payload, async_req=True)
>>> result = thread.get()
Args:
subaccount_payload (SubaccountPayload):
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:
SubAccountInfo
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['subaccount_payload'] = \
subaccount_payload
return self.call_with_http_info(**kwargs)
self.subaccounts_post = _Endpoint(settings={
'response_type': (SubAccountInfo, ),
'auth': ['apikey'],
'endpoint_path': '/subaccounts',
'operation_id': 'subaccounts_post',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'subaccount_payload',
],
'required': [
'subaccount_payload',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'subaccount_payload':
(SubaccountPayload, ),
},
'attribute_map': {},
'location_map': {
'subaccount_payload': 'body',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type':
['application/json']
},
api_client=api_client,
callable=__subaccounts_post)