def get_expired_inboxes_with_http_info(self, **kwargs): # noqa: E501
"""List records of expired inboxes # noqa: E501
Inboxes created with an expiration date will expire after the given date. An ExpiredInboxRecord is created that records the inboxes old ID and email address. You can still read emails in the inbox (using the inboxes old ID) but the email address associated with the inbox can no longer send or receive emails. Fetch expired inbox records to view the old inboxes properties # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_expired_inboxes_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int page: Optional page index in inbox sent email list pagination
:param int size: Optional page size in inbox sent email list pagination
:param str sort: Optional createdAt sort direction ASC or DESC
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(PageExpiredInboxRecordProjection, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['page', 'size', 'sort']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method get_expired_inboxes" % key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
if 'page' in local_var_params and local_var_params[
'page'] is not None: # noqa: E501
query_params.append(
('page', local_var_params['page'])) # noqa: E501
if 'size' in local_var_params and local_var_params[
'size'] is not None: # noqa: E501
query_params.append(
('size', local_var_params['size'])) # noqa: E501
if 'sort' in local_var_params and local_var_params[
'sort'] is not None: # noqa: E501
query_params.append(
('sort', local_var_params['sort'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/expired',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='PageExpiredInboxRecordProjection', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def wait_for_with_http_info(self, **kwargs): # noqa: E501
"""Wait for an email to match the provided filter conditions such as subject contains keyword. # noqa: E501
Generic waitFor method that will wait until an inbox meets given conditions or return immediately if already met # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.wait_for_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param WaitForConditions wait_for_conditions: Conditions to apply to emails that you are waiting for
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(list[EmailPreview], status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'wait_for_conditions'
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method wait_for" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'wait_for_conditions' in local_var_params:
body_params = local_var_params['wait_for_conditions']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/waitFor', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='list[EmailPreview]', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_expired_inbox_record_with_http_info(self, expired_id,
**kwargs): # noqa: E501
"""Get an expired inbox record # noqa: E501
Inboxes created with an expiration date will expire after the given date and be moved to an ExpiredInbox entity. You can still read emails in the inbox but it can no longer send or receive emails. Fetch the expired inboxes to view the old inboxes properties # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_expired_inbox_record_with_http_info(expired_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str expired_id: ID of the ExpiredInboxRecord you want to retrieve. This is different from the ID of the inbox you are interested in. See other methods for getting ExpiredInboxRecord for an inbox inboxId) (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(ExpiredInboxDto, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['expired_id']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method get_expired_inbox_record" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'expired_id' is set
if self.api_client.client_side_validation and (
'expired_id' not in local_var_params or # noqa: E501
local_var_params['expired_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `expired_id` when calling `get_expired_inbox_record`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'expired_id' in local_var_params:
path_params['expiredId'] = local_var_params[
'expired_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/expired/{expiredId}',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='ExpiredInboxDto', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_export_link_with_http_info(self, export_type, export_options,
**kwargs): # noqa: E501
"""Get export link # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_export_link_with_http_info(export_type, export_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str export_type: (required)
:param ExportOptions export_options: (required)
:param str api_key:
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(ExportLink, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['export_type', 'export_options', 'api_key']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method get_export_link" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'export_type' is set
if self.api_client.client_side_validation and (
'export_type' not in local_var_params or # noqa: E501
local_var_params['export_type'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `export_type` when calling `get_export_link`"
) # noqa: E501
# verify the required parameter 'export_options' is set
if self.api_client.client_side_validation and (
'export_options' not in local_var_params or # noqa: E501
local_var_params['export_options'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `export_options` when calling `get_export_link`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'export_type' in local_var_params and local_var_params[
'export_type'] is not None: # noqa: E501
query_params.append(
('exportType', local_var_params['export_type'])) # noqa: E501
if 'api_key' in local_var_params and local_var_params[
'api_key'] is not None: # noqa: E501
query_params.append(
('apiKey', local_var_params['api_key'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'export_options' in local_var_params:
body_params = local_var_params['export_options']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['*/*']) # noqa: E501
# HTTP header `Content-Type`
header_params[
'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/export',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='ExportLink', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def bulk_send_emails_with_http_info(self, bulk_send_email_options,
**kwargs): # noqa: E501
"""Bulk Send Emails # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.bulk_send_emails_with_http_info(bulk_send_email_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param BulkSendEmailOptions bulk_send_email_options: bulkSendEmailOptions (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: None
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['bulk_send_email_options']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method bulk_send_emails" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'bulk_send_email_options' is set
if self.api_client.client_side_validation and (
'bulk_send_email_options' not in local_var_params
or # noqa: E501
local_var_params['bulk_send_email_options'] is None
): # noqa: E501
raise ApiValueError(
"Missing the required parameter `bulk_send_email_options` when calling `bulk_send_emails`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'bulk_send_email_options' in local_var_params:
body_params = local_var_params['bulk_send_email_options']
# HTTP header `Content-Type`
header_params[
'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/bulk/send',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def delete_inbox_forwarders_with_http_info(self, **kwargs): # noqa: E501
"""Delete inbox forwarders # noqa: E501
Delete inbox forwarders. Accepts optional inboxId filter. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_inbox_forwarders_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str inbox_id: Optional inbox id to attach forwarder to
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: None
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['inbox_id']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method delete_inbox_forwarders" % key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
if 'inbox_id' in local_var_params and local_var_params[
'inbox_id'] is not None: # noqa: E501
query_params.append(
('inboxId', local_var_params['inbox_id'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/forwarders',
'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_inbox_forwarders_with_http_info(self, **kwargs): # noqa: E501
"""List inbox forwarders # noqa: E501
List all forwarders attached to an inbox # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_inbox_forwarders_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str inbox_id: Optional inbox id to get forwarders from
:param int page: Optional page index in inbox forwarder list pagination
:param str search_filter: Optional search filter
:param int size: Optional page size in inbox forwarder list pagination
:param str sort: Optional createdAt sort direction ASC or DESC
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(PageInboxForwarderDto, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['inbox_id', 'page', 'search_filter', 'size', 'sort']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method get_inbox_forwarders" % key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
if 'inbox_id' in local_var_params and local_var_params[
'inbox_id'] is not None: # noqa: E501
query_params.append(
('inboxId', local_var_params['inbox_id'])) # noqa: E501
if 'page' in local_var_params and local_var_params[
'page'] is not None: # noqa: E501
query_params.append(
('page', local_var_params['page'])) # noqa: E501
if 'search_filter' in local_var_params and local_var_params[
'search_filter'] is not None: # noqa: E501
query_params.append(
('searchFilter',
local_var_params['search_filter'])) # noqa: E501
if 'size' in local_var_params and local_var_params[
'size'] is not None: # noqa: E501
query_params.append(
('size', local_var_params['size'])) # noqa: E501
if 'sort' in local_var_params and local_var_params[
'sort'] is not None: # noqa: E501
query_params.append(
('sort', local_var_params['sort'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/forwarders',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='PageInboxForwarderDto', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def create_tracking_pixel_with_http_info(self,
create_tracking_pixel_options,
**kwargs): # noqa: E501
"""Create tracking pixel # noqa: E501
Create a tracking pixel. A tracking pixel is an image that can be embedded in an email. When the email is viewed and the image is seen MailSlurp will mark the pixel as seen. Use tracking pixels to monitor email open events. You can receive open notifications via webhook or by fetching the pixel. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_tracking_pixel_with_http_info(create_tracking_pixel_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param CreateTrackingPixelOptions create_tracking_pixel_options: (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(TrackingPixelDto, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['create_tracking_pixel_options']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method create_tracking_pixel" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'create_tracking_pixel_options' is set
if self.api_client.client_side_validation and (
'create_tracking_pixel_options' not in local_var_params
or # noqa: E501
local_var_params['create_tracking_pixel_options'] is None
): # noqa: E501
raise ApiValueError(
"Missing the required parameter `create_tracking_pixel_options` when calling `create_tracking_pixel`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'create_tracking_pixel_options' in local_var_params:
body_params = local_var_params['create_tracking_pixel_options']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['*/*']) # noqa: E501
# HTTP header `Content-Type`
header_params[
'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/tracking/pixels',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='TrackingPixelDto', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_group_with_contacts_paginated_with_http_info(
self, group_id, **kwargs): # noqa: E501
"""Get group and paginated contacts belonging to it # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_group_with_contacts_paginated_with_http_info(group_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str group_id: groupId (required)
:param int page: Optional page index in group contact pagination
:param int size: Optional page size in group contact pagination
:param str sort: Optional createdAt sort direction ASC or DESC
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(PageContactProjection, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['group_id', 'page', 'size', 'sort']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_group_with_contacts_paginated" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'group_id' is set
if self.api_client.client_side_validation and (
'group_id' not in local_var_params or # noqa: E501
local_var_params['group_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `group_id` when calling `get_group_with_contacts_paginated`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'group_id' in local_var_params:
path_params['groupId'] = local_var_params['group_id'] # noqa: E501
query_params = []
if 'page' in local_var_params and local_var_params[
'page'] is not None: # noqa: E501
query_params.append(
('page', local_var_params['page'])) # noqa: E501
if 'size' in local_var_params and local_var_params[
'size'] is not None: # noqa: E501
query_params.append(
('size', local_var_params['size'])) # noqa: E501
if 'sort' in local_var_params and local_var_params[
'sort'] is not None: # noqa: E501
query_params.append(
('sort', local_var_params['sort'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/groups/{groupId}/contacts-paginated',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='PageContactProjection', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def update_domain_with_http_info(self, id, update_domain_options,
**kwargs): # noqa: E501
"""Update a domain # noqa: E501
Update values on a domain. Note you cannot change the domain name as it is immutable. Recreate the domain if you need to alter this. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_domain_with_http_info(id, update_domain_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str id: (required)
:param UpdateDomainOptions update_domain_options: (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(DomainDto, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['id', 'update_domain_options']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method update_domain" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'id' is set
if self.api_client.client_side_validation and (
'id' not in local_var_params or # noqa: E501
local_var_params['id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `id` when calling `update_domain`"
) # noqa: E501
# verify the required parameter 'update_domain_options' is set
if self.api_client.client_side_validation and (
'update_domain_options' not in local_var_params
or # noqa: E501
local_var_params['update_domain_options'] is None
): # noqa: E501
raise ApiValueError(
"Missing the required parameter `update_domain_options` when calling `update_domain`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'id' in local_var_params:
path_params['id'] = local_var_params['id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'update_domain_options' in local_var_params:
body_params = local_var_params['update_domain_options']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['*/*']) # noqa: E501
# HTTP header `Content-Type`
header_params[
'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/domains/{id}',
'PUT',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='DomainDto', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def wait_for_nth_missed_email_with_http_info(self, index,
**kwargs): # noqa: E501
"""Wait for Nth missed email # noqa: E501
Wait for 0 based index missed email # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.wait_for_nth_missed_email_with_http_info(index, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int index: Zero based index of the email to wait for. If 1 missed email already and you want to wait for the 2nd email pass index=1 (required)
:param str inbox_id: Optional inbox ID filter
:param int timeout: Optional timeout milliseconds
:param datetime since: Filter by created at after the given timestamp
:param datetime before: Filter by created at before the given timestamp
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(MissedEmail, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['index', 'inbox_id', 'timeout', 'since', 'before']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method wait_for_nth_missed_email" %
key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'index' is set
if self.api_client.client_side_validation and (
'index' not in local_var_params or # noqa: E501
local_var_params['index'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `index` when calling `wait_for_nth_missed_email`"
) # noqa: E501
if self.api_client.client_side_validation and 'index' in local_var_params and local_var_params[
'index'] > 2147483647: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `index` when calling `wait_for_nth_missed_email`, must be a value less than or equal to `2147483647`"
) # noqa: E501
if self.api_client.client_side_validation and 'index' in local_var_params and local_var_params[
'index'] < 0: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `index` when calling `wait_for_nth_missed_email`, must be a value greater than or equal to `0`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'inbox_id' in local_var_params and local_var_params[
'inbox_id'] is not None: # noqa: E501
query_params.append(
('inboxId', local_var_params['inbox_id'])) # noqa: E501
if 'timeout' in local_var_params and local_var_params[
'timeout'] is not None: # noqa: E501
query_params.append(
('timeout', local_var_params['timeout'])) # noqa: E501
if 'index' in local_var_params and local_var_params[
'index'] is not None: # noqa: E501
query_params.append(
('index', local_var_params['index'])) # noqa: E501
if 'since' in local_var_params and local_var_params[
'since'] is not None: # noqa: E501
query_params.append(
('since', local_var_params['since'])) # noqa: E501
if 'before' in local_var_params and local_var_params[
'before'] is not None: # noqa: E501
query_params.append(
('before', local_var_params['before'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['*/*']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/missed-emails/waitForNthMissedEmail',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='MissedEmail', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def create_domain_with_http_info(self, create_domain_options,
**kwargs): # noqa: E501
"""Create Domain # noqa: E501
Link a domain that you own with MailSlurp so you can create email addresses using it. Endpoint returns DNS records used for validation. You must add these verification records to your host provider's DNS setup to verify the domain. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_domain_with_http_info(create_domain_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param CreateDomainOptions create_domain_options: (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(DomainDto, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['create_domain_options']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method create_domain" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'create_domain_options' is set
if self.api_client.client_side_validation and (
'create_domain_options' not in local_var_params
or # noqa: E501
local_var_params['create_domain_options'] is None
): # noqa: E501
raise ApiValueError(
"Missing the required parameter `create_domain_options` when calling `create_domain`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'create_domain_options' in local_var_params:
body_params = local_var_params['create_domain_options']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['*/*']) # noqa: E501
# HTTP header `Content-Type`
header_params[
'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/domains',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='DomainDto', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def filter_bounced_recipient_with_http_info(self, filter_bounced_recipients_options, **kwargs): # noqa: E501
"""Filter a list of email recipients and remove those who have bounced # noqa: E501
Prevent email sending errors by remove recipients who have resulted in past email bounces or complaints # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.filter_bounced_recipient_with_http_info(filter_bounced_recipients_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param FilterBouncedRecipientsOptions filter_bounced_recipients_options: (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(FilterBouncedRecipientsResult, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'filter_bounced_recipients_options'
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method filter_bounced_recipient" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'filter_bounced_recipients_options' is set
if self.api_client.client_side_validation and ('filter_bounced_recipients_options' not in local_var_params or # noqa: E501
local_var_params['filter_bounced_recipients_options'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `filter_bounced_recipients_options` when calling `filter_bounced_recipient`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'filter_bounced_recipients_options' in local_var_params:
body_params = local_var_params['filter_bounced_recipients_options']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['*/*']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/bounce/filter-recipients', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='FilterBouncedRecipientsResult', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def wait_for_nth_email_with_http_info(self, **kwargs): # noqa: E501
"""Wait for or fetch the email with a given index in the inbox specified. If index doesn't exist waits for it to exist or timeout to occur. # noqa: E501
If nth email is already present in inbox then return it. If not hold the connection open until timeout expires or the nth email is received and returned. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.wait_for_nth_email_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int delay: Max milliseconds delay between calls
:param str inbox_id: Id of the inbox you are fetching emails from
:param int index: Zero based index of the email to wait for. If an inbox has 1 email already and you want to wait for the 2nd email pass index=1
:param datetime since: Filter for emails that were received after the given timestamp
:param str sort: Sort direction
:param int timeout: Max milliseconds to wait for the nth email if not already present
:param bool unread_only: Optional filter for unread only
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(Email, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'delay',
'inbox_id',
'index',
'since',
'sort',
'timeout',
'unread_only'
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method wait_for_nth_email" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
if 'delay' in local_var_params and local_var_params['delay'] is not None: # noqa: E501
query_params.append(('delay', local_var_params['delay'])) # noqa: E501
if 'inbox_id' in local_var_params and local_var_params['inbox_id'] is not None: # noqa: E501
query_params.append(('inboxId', local_var_params['inbox_id'])) # noqa: E501
if 'index' in local_var_params and local_var_params['index'] is not None: # noqa: E501
query_params.append(('index', local_var_params['index'])) # noqa: E501
if 'since' in local_var_params and local_var_params['since'] is not None: # noqa: E501
query_params.append(('since', local_var_params['since'])) # noqa: E501
if 'sort' in local_var_params and local_var_params['sort'] is not None: # noqa: E501
query_params.append(('sort', local_var_params['sort'])) # noqa: E501
if 'timeout' in local_var_params and local_var_params['timeout'] is not None: # noqa: E501
query_params.append(('timeout', local_var_params['timeout'])) # noqa: E501
if 'unread_only' in local_var_params and local_var_params['unread_only'] is not None: # noqa: E501
query_params.append(('unreadOnly', local_var_params['unread_only'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/waitForNthEmail', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Email', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_expiration_defaults_with_http_info(self, **kwargs): # noqa: E501
"""Get default expiration settings # noqa: E501
Return default times used for inbox expiration # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_expiration_defaults_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(ExpirationDefaults, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = []
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method get_expiration_defaults" % key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/expired/defaults',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='ExpirationDefaults', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def remove_contacts_from_group_with_http_info(self, group_id,
update_group_contacts_option,
**kwargs): # noqa: E501
"""Remove contacts from a group # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.remove_contacts_from_group_with_http_info(group_id, update_group_contacts_option, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str group_id: groupId (required)
:param UpdateGroupContacts update_group_contacts_option: updateGroupContactsOption (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(GroupContactsDto, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['group_id', 'update_group_contacts_option']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method remove_contacts_from_group" %
key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'group_id' is set
if self.api_client.client_side_validation and (
'group_id' not in local_var_params or # noqa: E501
local_var_params['group_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `group_id` when calling `remove_contacts_from_group`"
) # noqa: E501
# verify the required parameter 'update_group_contacts_option' is set
if self.api_client.client_side_validation and (
'update_group_contacts_option' not in local_var_params
or # noqa: E501
local_var_params['update_group_contacts_option'] is None
): # noqa: E501
raise ApiValueError(
"Missing the required parameter `update_group_contacts_option` when calling `remove_contacts_from_group`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'group_id' in local_var_params:
path_params['groupId'] = local_var_params['group_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'update_group_contacts_option' in local_var_params:
body_params = local_var_params['update_group_contacts_option']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params[
'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/groups/{groupId}/contacts',
'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='GroupContactsDto', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def create_new_email_address_with_http_info(self, **kwargs): # noqa: E501
"""Create new random inbox # noqa: E501
Returns an Inbox with an `id` and an `emailAddress` # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_new_email_address_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param bool allow_team_access: allowTeamAccess
:param datetime expires_at: expiresAt
:param int expires_in: expiresIn
:param bool use_domain_pool: useDomainPool
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(Inbox, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'allow_team_access', 'expires_at', 'expires_in', 'use_domain_pool'
]
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method create_new_email_address" % key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
if 'allow_team_access' in local_var_params and local_var_params[
'allow_team_access'] is not None: # noqa: E501
query_params.append(
('allowTeamAccess',
local_var_params['allow_team_access'])) # noqa: E501
if 'expires_at' in local_var_params and local_var_params[
'expires_at'] is not None: # noqa: E501
query_params.append(
('expiresAt', local_var_params['expires_at'])) # noqa: E501
if 'expires_in' in local_var_params and local_var_params[
'expires_in'] is not None: # noqa: E501
query_params.append(
('expiresIn', local_var_params['expires_in'])) # noqa: E501
if 'use_domain_pool' in local_var_params and local_var_params[
'use_domain_pool'] is not None: # noqa: E501
query_params.append(
('useDomainPool',
local_var_params['use_domain_pool'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/createInbox',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Inbox', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def submit_form_with_http_info(self, **kwargs): # noqa: E501
"""Submit a form to be parsed and sent as an email to an address determined by the form fields # noqa: E501
This endpoint allows you to submit HTML forms and receive the field values and files via email. #### Parameters The endpoint looks for special meta parameters in the form fields OR in the URL request parameters. The meta parameters can be used to specify the behaviour of the email. You must provide at-least a `_to` email address to tell the endpoint where the form should be emailed. These can be submitted as hidden HTML input fields with the corresponding `name` attributes or as URL query parameters such as `[email protected]` The endpoint takes all other form fields that are named and includes them in the message body of the email. Files are sent as attachments. #### Submitting This endpoint accepts form submission via POST method. It accepts `application/x-www-form-urlencoded`, and `multipart/form-data` content-types. #### HTML Example ```html <form action=\"https://api.mailslurp.com/forms\" method=\"post\" > <input name=\"_to\" type=\"hidden\" value=\"[email protected]\"/> <textarea name=\"feedback\"></textarea> <button type=\"submit\">Submit</button> </form> ``` #### URL Example ```html <form action=\"https://api.mailslurp.com/[email protected]\" method=\"post\" > <textarea name=\"feedback\"></textarea> <button type=\"submit\">Submit</button> </form> ``` The email address is specified by a `_to` field OR is extracted from an email alias specified by a `_toAlias` field (see the alias controller for more information). Endpoint accepts . You can specify a content type in HTML forms using the `enctype` attribute, for instance: `<form enctype=\"multipart/form-data\">`. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.submit_form_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str email_address: Email address of the submitting user. Include this if you wish to record the submitters email address and reply to it later.
:param str redirect_to: Optional URL to redirect form submitter to after submission. If not present user will see a success message.
:param str spam_check: Optional but recommended field that catches spammers out. Include as a hidden form field but LEAVE EMPTY. Spam-bots will usually fill every field. If the _spamCheck field is filled the form submission will be ignored.
:param str subject: Optional subject of the email that will be sent.
:param str success_message: Optional success message to display if no _redirectTo present.
:param str to: The email address that submitted form should be sent to.
:param str other_parameters: All other parameters or fields will be accepted and attached to the sent email. This includes files and any HTML form field with a name. These fields will become the body of the email that is sent.
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(str, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'email_address', 'redirect_to', 'spam_check', 'subject',
'success_message', 'to', 'other_parameters'
]
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method submit_form" % key)
local_var_params[key] = val
del local_var_params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
if 'email_address' in local_var_params:
form_params.append(
('_emailAddress',
local_var_params['email_address'])) # noqa: E501
if 'redirect_to' in local_var_params:
form_params.append(
('_redirectTo', local_var_params['redirect_to'])) # noqa: E501
if 'spam_check' in local_var_params:
form_params.append(
('_spamCheck', local_var_params['spam_check'])) # noqa: E501
if 'subject' in local_var_params:
form_params.append(
('_subject', local_var_params['subject'])) # noqa: E501
if 'success_message' in local_var_params:
form_params.append(
('_successMessage',
local_var_params['success_message'])) # noqa: E501
if 'to' in local_var_params:
form_params.append(('_to', local_var_params['to'])) # noqa: E501
if 'other_parameters' in local_var_params:
form_params.append(
('otherParameters',
local_var_params['other_parameters'])) # noqa: E501
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params[
'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['multipart/form-data',
'application/x-www-form-urlencoded']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/forms',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='str', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_inbox_forwarder_with_http_info(self, id, **kwargs): # noqa: E501
"""Get an inbox forwarder # noqa: E501
Get inbox ruleset # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_inbox_forwarder_with_http_info(id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str id: ID of inbox forwarder (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(InboxForwarderDto, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['id']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method get_inbox_forwarder" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'id' is set
if self.api_client.client_side_validation and (
'id' not in local_var_params or # noqa: E501
local_var_params['id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `id` when calling `get_inbox_forwarder`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'id' in local_var_params:
path_params['id'] = local_var_params['id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/forwarders/{id}',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='InboxForwarderDto', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def verify_email_address_with_http_info(self, verify_email_address_options, **kwargs): # noqa: E501
"""Deprecated. Use the EmailVerificationController methods for more accurate and reliable functionality. Verify the existence of an email address at a given mail server. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.verify_email_address_with_http_info(verify_email_address_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param VerifyEmailAddressOptions verify_email_address_options: (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(EmailVerificationResult, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'verify_email_address_options'
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method verify_email_address" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'verify_email_address_options' is set
if self.api_client.client_side_validation and ('verify_email_address_options' not in local_var_params or # noqa: E501
local_var_params['verify_email_address_options'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `verify_email_address_options` when calling `verify_email_address`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'verify_email_address_options' in local_var_params:
body_params = local_var_params['verify_email_address_options']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['*/*']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/mail-server/verify/email-address', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='EmailVerificationResult', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def create_new_inbox_forwarder_with_http_info(
self, create_inbox_forwarder_options, **kwargs): # noqa: E501
"""Create an inbox forwarder # noqa: E501
Create a new inbox rule for forwarding, blocking, and allowing emails when sending and receiving # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_new_inbox_forwarder_with_http_info(create_inbox_forwarder_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param CreateInboxForwarderOptions create_inbox_forwarder_options: createInboxForwarderOptions (required)
:param str inbox_id: Inbox id to attach forwarder to
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(InboxForwarderDto, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['create_inbox_forwarder_options', 'inbox_id']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method create_new_inbox_forwarder" %
key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'create_inbox_forwarder_options' is set
if self.api_client.client_side_validation and (
'create_inbox_forwarder_options' not in local_var_params
or # noqa: E501
local_var_params['create_inbox_forwarder_options'] is None
): # noqa: E501
raise ApiValueError(
"Missing the required parameter `create_inbox_forwarder_options` when calling `create_new_inbox_forwarder`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'inbox_id' in local_var_params and local_var_params[
'inbox_id'] is not None: # noqa: E501
query_params.append(
('inboxId', local_var_params['inbox_id'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'create_inbox_forwarder_options' in local_var_params:
body_params = local_var_params['create_inbox_forwarder_options']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params[
'Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/forwarders',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='InboxForwarderDto', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_validation_requests_with_http_info(self, **kwargs): # noqa: E501
"""Validate a list of email addresses. Per unit billing. See your plan for pricing. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_validation_requests_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int page: Optional page index in list pagination
:param int size: Optional page size for paginated result list.
:param str sort: Optional createdAt sort direction ASC or DESC
:param str search_filter: Optional search filter
:param datetime since: Filter by created at after the given timestamp
:param datetime before: Filter by created at before the given timestamp
:param bool is_valid: Filter where email is valid is true or false
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(PageEmailValidationRequest, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'page', 'size', 'sort', 'search_filter', 'since', 'before',
'is_valid'
]
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method get_validation_requests" % key)
local_var_params[key] = val
del local_var_params['kwargs']
if self.api_client.client_side_validation and 'page' in local_var_params and local_var_params[
'page'] > 9223372036854775807: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `page` when calling `get_validation_requests`, must be a value less than or equal to `9223372036854775807`"
) # noqa: E501
if self.api_client.client_side_validation and 'page' in local_var_params and local_var_params[
'page'] < 0: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `page` when calling `get_validation_requests`, must be a value greater than or equal to `0`"
) # noqa: E501
if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params[
'size'] > 100: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `size` when calling `get_validation_requests`, must be a value less than or equal to `100`"
) # noqa: E501
if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params[
'size'] < 1: # noqa: E501
raise ApiValueError(
"Invalid value for parameter `size` when calling `get_validation_requests`, must be a value greater than or equal to `1`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'page' in local_var_params and local_var_params[
'page'] is not None: # noqa: E501
query_params.append(
('page', local_var_params['page'])) # noqa: E501
if 'size' in local_var_params and local_var_params[
'size'] is not None: # noqa: E501
query_params.append(
('size', local_var_params['size'])) # noqa: E501
if 'sort' in local_var_params and local_var_params[
'sort'] is not None: # noqa: E501
query_params.append(
('sort', local_var_params['sort'])) # noqa: E501
if 'search_filter' in local_var_params and local_var_params[
'search_filter'] is not None: # noqa: E501
query_params.append(
('searchFilter',
local_var_params['search_filter'])) # noqa: E501
if 'since' in local_var_params and local_var_params[
'since'] is not None: # noqa: E501
query_params.append(
('since', local_var_params['since'])) # noqa: E501
if 'before' in local_var_params and local_var_params[
'before'] is not None: # noqa: E501
query_params.append(
('before', local_var_params['before'])) # noqa: E501
if 'is_valid' in local_var_params and local_var_params[
'is_valid'] is not None: # noqa: E501
query_params.append(
('isValid', local_var_params['is_valid'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['*/*']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/email-verification/validation-requests',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='PageEmailValidationRequest', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def export_entities_with_http_info(self, export_type, api_key,
output_format, **kwargs): # noqa: E501
"""Export inboxes link callable via browser # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.export_entities_with_http_info(export_type, api_key, output_format, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str export_type: (required)
:param str api_key: (required)
:param str output_format: (required)
:param str filter:
:param str list_separator_token:
:param bool exclude_previously_exported:
:param datetime created_earliest_time:
:param datetime created_oldest_time:
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(list[str], status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'export_type', 'api_key', 'output_format', 'filter',
'list_separator_token', 'exclude_previously_exported',
'created_earliest_time', 'created_oldest_time'
]
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method export_entities" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'export_type' is set
if self.api_client.client_side_validation and (
'export_type' not in local_var_params or # noqa: E501
local_var_params['export_type'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `export_type` when calling `export_entities`"
) # noqa: E501
# verify the required parameter 'api_key' is set
if self.api_client.client_side_validation and (
'api_key' not in local_var_params or # noqa: E501
local_var_params['api_key'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `api_key` when calling `export_entities`"
) # noqa: E501
# verify the required parameter 'output_format' is set
if self.api_client.client_side_validation and (
'output_format' not in local_var_params or # noqa: E501
local_var_params['output_format'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `output_format` when calling `export_entities`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'export_type' in local_var_params and local_var_params[
'export_type'] is not None: # noqa: E501
query_params.append(
('exportType', local_var_params['export_type'])) # noqa: E501
if 'api_key' in local_var_params and local_var_params[
'api_key'] is not None: # noqa: E501
query_params.append(
('apiKey', local_var_params['api_key'])) # noqa: E501
if 'output_format' in local_var_params and local_var_params[
'output_format'] is not None: # noqa: E501
query_params.append(
('outputFormat',
local_var_params['output_format'])) # noqa: E501
if 'filter' in local_var_params and local_var_params[
'filter'] is not None: # noqa: E501
query_params.append(
('filter', local_var_params['filter'])) # noqa: E501
if 'list_separator_token' in local_var_params and local_var_params[
'list_separator_token'] is not None: # noqa: E501
query_params.append(
('listSeparatorToken',
local_var_params['list_separator_token'])) # noqa: E501
if 'exclude_previously_exported' in local_var_params and local_var_params[
'exclude_previously_exported'] is not None: # noqa: E501
query_params.append((
'excludePreviouslyExported',
local_var_params['exclude_previously_exported'])) # noqa: E501
if 'created_earliest_time' in local_var_params and local_var_params[
'created_earliest_time'] is not None: # noqa: E501
query_params.append(
('createdEarliestTime',
local_var_params['created_earliest_time'])) # noqa: E501
if 'created_oldest_time' in local_var_params and local_var_params[
'created_oldest_time'] is not None: # noqa: E501
query_params.append(
('createdOldestTime',
local_var_params['created_oldest_time'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['*/*']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/export',
'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='list[str]', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def delete_template_with_http_info(self, template_id,
**kwargs): # noqa: E501
"""Delete Template # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_template_with_http_info(template_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str template_id: (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: None
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['template_id']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method delete_template" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'template_id' is set
if self.api_client.client_side_validation and (
'template_id' not in local_var_params or # noqa: E501
local_var_params['template_id'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `template_id` when calling `delete_template`"
) # noqa: E501
collection_formats = {}
path_params = {}
if 'template_id' in local_var_params:
path_params['templateId'] = local_var_params[
'template_id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/templates/{templateId}',
'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def bulk_create_inboxes_with_http_info(self, count,
**kwargs): # noqa: E501
"""Bulk create Inboxes (email addresses) # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.bulk_create_inboxes_with_http_info(count, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int count: Number of inboxes to be created in bulk (required)
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(list[Inbox], status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['count']
all_params.extend([
'async_req', '_return_http_data_only', '_preload_content',
'_request_timeout'
])
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError("Got an unexpected keyword argument '%s'"
" to method bulk_create_inboxes" % key)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'count' is set
if self.api_client.client_side_validation and (
'count' not in local_var_params or # noqa: E501
local_var_params['count'] is None): # noqa: E501
raise ApiValueError(
"Missing the required parameter `count` when calling `bulk_create_inboxes`"
) # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'count' in local_var_params and local_var_params[
'count'] is not None: # noqa: E501
query_params.append(
('count', local_var_params['count'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/bulk/inboxes',
'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='list[Inbox]', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get(
'_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def wait_for_matching_first_email_with_http_info(self, match_options, **kwargs): # noqa: E501
"""Wait for or return the first email that matches provided MatchOptions array # noqa: E501
Perform a search of emails in an inbox with the given patterns. If a result if found then return or else retry the search until a result is found or timeout is reached. Match options allow simple CONTAINS or EQUALS filtering on SUBJECT, TO, BCC, CC, and FROM. See the `MatchOptions` object for options. An example payload is `{ matches: [{field: 'SUBJECT',should:'CONTAIN',value:'needle'}] }`. You can use an array of matches and they will be applied sequentially to filter out emails. If you want to perform matches and extractions of content using Regex patterns see the EmailController `getEmailContentMatch` method. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.wait_for_matching_first_email_with_http_info(match_options, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param MatchOptions match_options: matchOptions (required)
:param int delay: Max milliseconds delay between calls
:param str inbox_id: Id of the inbox we are matching an email for
:param datetime since: Filter for emails that were received after the given timestamp
:param str sort: Sort direction
:param int timeout: Max milliseconds to wait
:param bool unread_only: Optional filter for unread only
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: 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.
:return: tuple(Email, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = [
'match_options',
'delay',
'inbox_id',
'since',
'sort',
'timeout',
'unread_only'
]
all_params.extend(
[
'async_req',
'_return_http_data_only',
'_preload_content',
'_request_timeout'
]
)
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method wait_for_matching_first_email" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'match_options' is set
if self.api_client.client_side_validation and ('match_options' not in local_var_params or # noqa: E501
local_var_params['match_options'] is None): # noqa: E501
raise ApiValueError("Missing the required parameter `match_options` when calling `wait_for_matching_first_email`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
if 'delay' in local_var_params and local_var_params['delay'] is not None: # noqa: E501
query_params.append(('delay', local_var_params['delay'])) # noqa: E501
if 'inbox_id' in local_var_params and local_var_params['inbox_id'] is not None: # noqa: E501
query_params.append(('inboxId', local_var_params['inbox_id'])) # noqa: E501
if 'since' in local_var_params and local_var_params['since'] is not None: # noqa: E501
query_params.append(('since', local_var_params['since'])) # noqa: E501
if 'sort' in local_var_params and local_var_params['sort'] is not None: # noqa: E501
query_params.append(('sort', local_var_params['sort'])) # noqa: E501
if 'timeout' in local_var_params and local_var_params['timeout'] is not None: # noqa: E501
query_params.append(('timeout', local_var_params['timeout'])) # noqa: E501
if 'unread_only' in local_var_params and local_var_params['unread_only'] is not None: # noqa: E501
query_params.append(('unreadOnly', local_var_params['unread_only'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'match_options' in local_var_params:
body_params = local_var_params['match_options']
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['API_KEY'] # noqa: E501
return self.api_client.call_api(
'/waitForMatchingFirstEmail', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='Email', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
