mailslurp-client-python

https://github.com/mailslurp/mailslurp-client-python

setup.py

from setuptools import setup, find_packages 

setup(
    name="mailslurp-client",
    version="15.19.22",
    description="Official MailSlurp Python SDK Email API",
    author="MailSlurp",
    author_email="contact@mailslurp.dev",
    url="https://www.mailslurp.com/python",
    keywords=["MailSlurp", "Email", "SMTP", "Mailer", "MailSlurp API", "Test"],
    install_requires=["urllib3 >= 1.15", "six >= 1.10", "certifi", "python-dateutil"],
    packages=find_packages(exclude=["test", "tests"]),
    include_package_data=True,
    long_description="""
# MailSlurp Python Client

> Create real email addresses on demand. Send and receive emails and attachments from code and tests using Python.

MailSlurp is an email API service that lets you create real email addresses in code. You can then send and receive emails and attachments in Python applications and tests.

## Video tutorial

[![Python email tutorial](https://www.mailslurp.com/video-thumbnails/python-tutorial.jpeg)](https://youtu.be/tcLJ3xX-H88)

## Quick links

- [API documentation](https://docs.mailslurp.com/api/)
- [Method Documentation](https://python.mailslurp.com/)
- [PyPI Package](https://pypi.org/project/mailslurp-client/)
- [Github Source](https://github.com/mailslurp/mailslurp-client-python)
- [Send email using SMTP in Python](https://www.mailslurp.com/smtp/python-send-email-smtp/)
- [SMTP access details](https://www.mailslurp.com/guides/smtp-imap/)

## Get started

This section describes how to get up and running with the Python client.

See the [examples page](https://www.mailslurp.com/examples/) for more examples and use with common frameworks such as Django, Flask and Pytest.

See the method documentation for a [list of all functions](https://python.mailslurp.com/) or jump to common controllers below:

- [InboxController](https://python.mailslurp.com/api/inbox_controller_api.html)
- [EmailController](https://python.mailslurp.com/api/email_controller_api.html)
- [SMSController](https://python.mailslurp.com/api/sms_controller_api.html)
- [WaitForController](https://python.mailslurp.com/api/wait_for_controller_api.html)

### Create API Key

First you'll need an API Key. [Create a free account](https://app.mailslurp.com) and copy the key from your dashboard.

### Install package

MailSlurp has an official PyPI package called `mailslurp-client`. It supports Python version 2 and 3.

```bash
pip install mailslurp-client
```

On some systems you may need to install `distutils`. If you encounter a `CERTIFICATE_VERIFY_VALID` error you can install `certifi` and `certifi-win32` for Windows:

```bash
pip install python-certifi-win32
```

### Configure

Once installed you can import `mailslurp_client` and create a [configuration](https://python.mailslurp.com/configuration.html) with your [API Key](https://app.mailslurp.com).

```python
import mailslurp_client

configuration = mailslurp_client.Configuration()
configuration.api_key["x-api-key"] = YOUR_API_KEY
```

Then you can create API controller instances using the configuration:

```python
with mailslurp_client.ApiClient(configuration) as api_client:
    api_instance = mailslurp_client.InboxControllerApi(api_client)
    
```

See the [controllers overview](https://python.mailslurp.com/api/index.html) for all API methods.

## Email usage examples

MailSlurp can be used to create email addresses than can send and receive real emails, SMS, and attachments in Python. 

### Create an email address
Create an inbox using the inbox controller:

```python
inbox_controller = mailslurp_client.InboxControllerApi(api_client)
inbox = inbox_controller.create_inbox_with_defaults()
self.assertTrue("@mailslurp" in inbox.email_address)
```

You can pass options using the `CreateInboxOptions` class:

```python
options = mailslurp_client.CreateInboxDto()
options.name = "Test inbox"
options.inbox_type = "SMTP_INBOX"
inbox = inbox_controller.create_inbox_with_options(options)
self.assertTrue("@mailslurp" in inbox.email_address)
```

See the [inbox controller](https://python.mailslurp.com/api/inbox_controller_api.html) for more methods.

### Access inbox using SMTP

```python
smtp_access = inbox_controller.get_imap_smtp_access(inbox_id=inbox.id)
self.assertIsNotNone(smtp_access.secure_smtp_server_host)
```

### Send with SMTP client

```python
# configure smtp client using access details
from smtplib import SMTP

with SMTP(
    host=smtp_access.secure_smtp_server_host,
    port=smtp_access.secure_smtp_server_port,
) as smtp:
    msg = "Subject: Test subject\r\n\r\nThis is the body"
    smtp.login(
        user=smtp_access.secure_smtp_username,
        password=smtp_access.secure_smtp_password,
    )
    smtp.sendmail(
        from_addr=inbox.email_address,
        to_addrs=[inbox.email_address],
        msg=msg,
    )
    smtp.quit()
```

### List inboxes

List inboxes using the [inbox controller](https://python.mailslurp.com/api/inbox_controller_api.html):

```python
inboxes = inbox_controller.get_all_inboxes(page=0)

# pagination properties
self.assertTrue(inboxes.total_pages > 0)
self.assertTrue(inboxes.total_elements > 0)

# view contents
self.assertIsNotNone(inboxes.content[0].email_address)
```

### Get an inbox

```python
inbox = inbox_controller.get_inbox(inbox_id=inbox.id)
self.assertTrue("@mailslurp" in inbox.email_address)

# get by email address
inbox_by_email = inbox_controller.get_inbox_by_email_address(
    inbox.email_address
)
self.assertTrue(inbox_by_email.exists)

# get by name
inbox_by_name = inbox_controller.get_inbox_by_name(inbox.name)
self.assertTrue(inbox_by_name.exists)
```

### Delete an inbox

```python
inbox_controller.delete_inbox(inbox_id=inbox.id)
```

### Upload attachments
To send attachments first upload the attachments as base64 encoded strings and use the returned attachment IDs when sending.

```python
import base64

attachment_controller = mailslurp_client.AttachmentControllerApi(api_client)
options = mailslurp_client.UploadAttachmentOptions(
    filename="test.txt",
    content_type="text/plain",
    base64_contents=base64.b64encode("Hello world".encode("utf-8")).decode(
        "utf-8"
    ),
)
attachment_ids = attachment_controller.upload_attachment(options)
self.assertTrue(len(attachment_ids) == 1)
```

### Send emails
Send emails with the [inbox controller](https://python.mailslurp.com/api/inbox_controller_api.html):

```python
send_options = mailslurp_client.SendEmailOptions(
    to=[recipient.email_address],
    subject="Hello",
    body="Here is your email body",
    attachments=attachment_ids,
)
sent = inbox_controller.send_email_and_confirm(
    inbox_id=inbox.id, send_email_options=send_options
)
self.assertTrue(sent.sent_at is not None)
```

### Receive emails and extract content
Use the [wait for controller](https://python.mailslurp.com/api/wait_for_controller_api.html) to wait for an expected email count to be satisfied and then return those emails.


```python
wait_for_controller = mailslurp_client.WaitForControllerApi(api_client)
email = wait_for_controller.wait_for_latest_email(
    inbox_id=inbox.id, timeout=60_000, unread_only=True
)
self.assertTrue("Hello" in email.subject)
```

### Email content matching

```python
matching_emails = wait_for_controller.wait_for_matching_emails(
    inbox_id=inbox.id,
    timeout=60_000,
    unread_only=False,
    match_options=mailslurp_client.MatchOptions(
        conditions=[
            mailslurp_client.ConditionOption(
                condition="HAS_ATTACHMENTS", value="TRUE"
            )
        ],
        matches=[
            mailslurp_client.MatchOption(
                field="SUBJECT", should="CONTAIN", value="Hello"
            )
        ],
    ),
    count=1,
)
self.assertTrue(len(matching_emails) > 0)
```

### Download attachments

```python
attachment_content = attachment_controller.download_attachment_as_base64_encoded(email.attachments[0])
attachment_metadata = attachment_controller.get_attachment_info(email.attachments[0])
self.assertEqual(attachment_metadata.content_type, "text/plain")
```

### Fetch email by ID

```python
email_controller = mailslurp_client.EmailControllerApi(api_client)
email = email_controller.get_email(email_id=email_id)
self.assertTrue("Hello" in email.subject)
```

### Verify email address

You can verify email addresses with MailSlurp. This will perform SMTP queries for the email address on your behalf.

```python
def test_validate_email(self):
    with mailslurp_client.ApiClient(configuration) as api_client:
        mailserver_controller = mailslurp_client.MailServerControllerApi(api_client)
        verify_options = mailslurp_client.VerifyEmailAddressOptions(email_address="test@gmail.com")
        result = mailserver_controller.verify_email_address(verify_options=verify_options)
        assert result.error is None
        assert result.is_valid is True
```

## SDK Documentation

See the [guides page](https://www.mailslurp.com/guides/) or [the examples](https://www.github.com/mailslurp/examples) or the [Method Documentation](https://python.mailslurp.com/) for full usage.    
    """,
    long_description_content_type="text/markdown"
)

mailslurp_client/rest.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import io
import json
import logging
import re
import ssl

import certifi
# python 2 and python 3 compatibility library
import six
from six.moves.urllib.parse import urlencode
import urllib3

from mailslurp_client.exceptions import ApiException, ApiValueError


logger = logging.getLogger(__name__)


class RESTResponse(io.IOBase):

    def __init__(self, resp):
        self.urllib3_response = resp
        self.status = resp.status
        self.reason = resp.reason
        self.data = resp.data

    def getheaders(self):
        """Returns a dictionary of the response headers."""
        return self.urllib3_response.getheaders()

    def getheader(self, name, default=None):
        """Returns a given response header."""
        return self.urllib3_response.getheader(name, default)


class RESTClientObject(object):

    def __init__(self, configuration, pools_size=4, maxsize=None):
        # urllib3.PoolManager will pass all kw parameters to connectionpool
        # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/poolmanager.py#L75  # noqa: E501
        # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/connectionpool.py#L680  # noqa: E501
        # maxsize is the number of requests to host that are allowed in parallel  # noqa: E501
        # Custom SSL certificates and client certificates: http://urllib3.readthedocs.io/en/latest/advanced-usage.html  # noqa: E501

        # cert_reqs
        if configuration.verify_ssl:
            cert_reqs = ssl.CERT_REQUIRED
        else:
            cert_reqs = ssl.CERT_NONE

        # ca_certs
        if configuration.ssl_ca_cert:
            ca_certs = configuration.ssl_ca_cert
        else:
            # if not set certificate file, use Mozilla's root certificates.
            ca_certs = certifi.where()

        addition_pool_args = {}
        if configuration.assert_hostname is not None:
            addition_pool_args['assert_hostname'] = configuration.assert_hostname  # noqa: E501

        if configuration.retries is not None:
            addition_pool_args['retries'] = configuration.retries

        if maxsize is None:
            if configuration.connection_pool_maxsize is not None:
                maxsize = configuration.connection_pool_maxsize
            else:
                maxsize = 4

        # https pool manager
        if configuration.proxy:
            self.pool_manager = urllib3.ProxyManager(
                num_pools=pools_size,
                maxsize=maxsize,
                cert_reqs=cert_reqs,
                ca_certs=ca_certs,
                cert_file=configuration.cert_file,
                key_file=configuration.key_file,
                proxy_url=configuration.proxy,
                proxy_headers=configuration.proxy_headers,
                **addition_pool_args
            )
        else:
            self.pool_manager = urllib3.PoolManager(
                num_pools=pools_size,
                maxsize=maxsize,
                cert_reqs=cert_reqs,
                ca_certs=ca_certs,
                cert_file=configuration.cert_file,
                key_file=configuration.key_file,
                **addition_pool_args
            )

    def request(self, method, url, query_params=None, headers=None,
                body=None, post_params=None, _preload_content=True,
                _request_timeout=None):
        """Perform requests.

        :param method: http request method
        :param url: http request url
        :param query_params: query parameters in the url
        :param headers: http request headers
        :param body: request json body, for `application/json`
        :param post_params: request post parameters,
                            `application/x-www-form-urlencoded`
                            and `multipart/form-data`
        :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.
        """
        method = method.upper()
        assert method in ['GET', 'HEAD', 'DELETE', 'POST', 'PUT',
                          'PATCH', 'OPTIONS']

        if post_params and body:
            raise ApiValueError(
                "body parameter cannot be used with post_params parameter."
            )

        post_params = post_params or {}
        headers = headers or {}

        timeout = None
        if _request_timeout:
            if isinstance(_request_timeout, (int, ) if six.PY3 else (int, long)):  # noqa: E501,F821
                timeout = urllib3.Timeout(total=_request_timeout)
            elif (isinstance(_request_timeout, tuple) and
                  len(_request_timeout) == 2):
                timeout = urllib3.Timeout(
                    connect=_request_timeout[0], read=_request_timeout[1])

        if 'Content-Type' not in headers:
            headers['Content-Type'] = 'application/json'

        try:
            # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
            if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']:
                if query_params:
                    url += '?' + urlencode(query_params)
                if re.search('json', headers['Content-Type'], re.IGNORECASE):
                    request_body = None
                    if body is not None:
                        request_body = json.dumps(body)
                    r = self.pool_manager.request(
                        method, url,
                        body=request_body,
                        preload_content=_preload_content,
                        timeout=timeout,
                        headers=headers)
                elif headers['Content-Type'] == 'application/x-www-form-urlencoded':  # noqa: E501
                    r = self.pool_manager.request(
                        method, url,
                        fields=post_params,
                        encode_multipart=False,
                        preload_content=_preload_content,
                        timeout=timeout,
                        headers=headers)
                elif headers['Content-Type'] == 'multipart/form-data':
                    # must del headers['Content-Type'], or the correct
                    # Content-Type which generated by urllib3 will be
                    # overwritten.
                    del headers['Content-Type']
                    r = self.pool_manager.request(
                        method, url,
                        fields=post_params,
                        encode_multipart=True,
                        preload_content=_preload_content,
                        timeout=timeout,
                        headers=headers)
                # Pass a `string` parameter directly in the body to support
                # other content types than Json when `body` argument is
                # provided in serialized form
                elif isinstance(body, str) or isinstance(body, bytes):
                    request_body = body
                    r = self.pool_manager.request(
                        method, url,
                        body=request_body,
                        preload_content=_preload_content,
                        timeout=timeout,
                        headers=headers)
                else:
                    # Cannot generate the request from given parameters
                    msg = """Cannot prepare a request message for provided
                             arguments. Please check that your arguments match
                             declared content type."""
                    raise ApiException(status=0, reason=msg)
            # For `GET`, `HEAD`
            else:
                r = self.pool_manager.request(method, url,
                                              fields=query_params,
                                              preload_content=_preload_content,
                                              timeout=timeout,
                                              headers=headers)
        except urllib3.exceptions.SSLError as e:
            msg = "{0}\n{1}".format(type(e).__name__, str(e))
            raise ApiException(status=0, reason=msg)

        if _preload_content:
            r = RESTResponse(r)

            # log response body
            logger.debug("response body: %s", r.data)

        if not 200 <= r.status <= 299:
            raise ApiException(http_resp=r)

        return r

    def GET(self, url, headers=None, query_params=None, _preload_content=True,
            _request_timeout=None):
        return self.request("GET", url,
                            headers=headers,
                            _preload_content=_preload_content,
                            _request_timeout=_request_timeout,
                            query_params=query_params)

    def HEAD(self, url, headers=None, query_params=None, _preload_content=True,
             _request_timeout=None):
        return self.request("HEAD", url,
                            headers=headers,
                            _preload_content=_preload_content,
                            _request_timeout=_request_timeout,
                            query_params=query_params)

    def OPTIONS(self, url, headers=None, query_params=None, post_params=None,
                body=None, _preload_content=True, _request_timeout=None):
        return self.request("OPTIONS", url,
                            headers=headers,
                            query_params=query_params,
                            post_params=post_params,
                            _preload_content=_preload_content,
                            _request_timeout=_request_timeout,
                            body=body)

    def DELETE(self, url, headers=None, query_params=None, body=None,
               _preload_content=True, _request_timeout=None):
        return self.request("DELETE", url,
                            headers=headers,
                            query_params=query_params,
                            _preload_content=_preload_content,
                            _request_timeout=_request_timeout,
                            body=body)

    def POST(self, url, headers=None, query_params=None, post_params=None,
             body=None, _preload_content=True, _request_timeout=None):
        return self.request("POST", url,
                            headers=headers,
                            query_params=query_params,
                            post_params=post_params,
                            _preload_content=_preload_content,
                            _request_timeout=_request_timeout,
                            body=body)

    def PUT(self, url, headers=None, query_params=None, post_params=None,
            body=None, _preload_content=True, _request_timeout=None):
        return self.request("PUT", url,
                            headers=headers,
                            query_params=query_params,
                            post_params=post_params,
                            _preload_content=_preload_content,
                            _request_timeout=_request_timeout,
                            body=body)

    def PATCH(self, url, headers=None, query_params=None, post_params=None,
              body=None, _preload_content=True, _request_timeout=None):
        return self.request("PATCH", url,
                            headers=headers,
                            query_params=query_params,
                            post_params=post_params,
                            _preload_content=_preload_content,
                            _request_timeout=_request_timeout,
                            body=body)

mailslurp_client/exceptions.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import six


class OpenApiException(Exception):
    """The base exception class for all OpenAPIExceptions"""


class ApiTypeError(OpenApiException, TypeError):
    def __init__(self, msg, path_to_item=None, valid_classes=None,
                 key_type=None):
        """ Raises an exception for TypeErrors

        Args:
            msg (str): the exception message

        Keyword Args:
            path_to_item (list): a list of keys an indices to get to the
                                 current_item
                                 None if unset
            valid_classes (tuple): the primitive classes that current item
                                   should be an instance of
                                   None if unset
            key_type (bool): False if our value is a value in a dict
                             True if it is a key in a dict
                             False if our item is an item in a list
                             None if unset
        """
        self.path_to_item = path_to_item
        self.valid_classes = valid_classes
        self.key_type = key_type
        full_msg = msg
        if path_to_item:
            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
        super(ApiTypeError, self).__init__(full_msg)


class ApiValueError(OpenApiException, ValueError):
    def __init__(self, msg, path_to_item=None):
        """
        Args:
            msg (str): the exception message

        Keyword Args:
            path_to_item (list) the path to the exception in the
                received_data dict. None if unset
        """

        self.path_to_item = path_to_item
        full_msg = msg
        if path_to_item:
            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
        super(ApiValueError, self).__init__(full_msg)


class ApiKeyError(OpenApiException, KeyError):
    def __init__(self, msg, path_to_item=None):
        """
        Args:
            msg (str): the exception message

        Keyword Args:
            path_to_item (None/list) the path to the exception in the
                received_data dict
        """
        self.path_to_item = path_to_item
        full_msg = msg
        if path_to_item:
            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
        super(ApiKeyError, self).__init__(full_msg)


class ApiException(OpenApiException):

    def __init__(self, status=None, reason=None, http_resp=None):
        if http_resp:
            self.status = http_resp.status
            self.reason = http_resp.reason
            self.body = http_resp.data
            self.headers = http_resp.getheaders()
        else:
            self.status = status
            self.reason = reason
            self.body = None
            self.headers = None

    def __str__(self):
        """Custom error messages for exception"""
        error_message = "({0})\n"\
                        "Reason: {1}\n".format(self.status, self.reason)
        if self.headers:
            error_message += "HTTP response headers: {0}\n".format(
                self.headers)

        if self.body:
            error_message += "HTTP response body: {0}\n".format(self.body)

        return error_message


def render_path(path_to_item):
    """Returns a string representation of a path"""
    result = ""
    for pth in path_to_item:
        if isinstance(pth, six.integer_types):
            result += "[{0}]".format(pth)
        else:
            result += "['{0}']".format(pth)
    return result

mailslurp_client/configuration.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import copy
import logging
import multiprocessing
import sys
import urllib3

import six
from six.moves import http_client as httplib


class Configuration(object):
    """NOTE: This class is auto generated by OpenAPI Generator

    Ref: https://openapi-generator.tech
    Do not edit the class manually.

    :param host: Base url
    :param api_key: Dict to store API key(s).
      Each entry in the dict specifies an API key.
      The dict key is the name of the security scheme in the OAS specification.
      The dict value is the API key secret.
    :param api_key_prefix: Dict to store API prefix (e.g. Bearer)
      The dict key is the name of the security scheme in the OAS specification.
      The dict value is an API key prefix when generating the auth data.
    :param username: Username for HTTP basic authentication
    :param password: Password for HTTP basic authentication
    :param discard_unknown_keys: Boolean value indicating whether to discard
      unknown properties. A server may send a response that includes additional
      properties that are not known by the client in the following scenarios:
      1. The OpenAPI document is incomplete, i.e. it does not match the server
         implementation.
      2. The client was generated using an older version of the OpenAPI document
         and the server has been upgraded since then.
      If a schema in the OpenAPI document defines the additionalProperties attribute,
      then all undeclared properties received by the server are injected into the
      additional properties map. In that case, there are undeclared properties, and
      nothing to discard.

    :Example:

    API Key Authentication Example.
    Given the following security scheme in the OpenAPI specification:
      components:
        securitySchemes:
          cookieAuth:         # name for the security scheme
            type: apiKey
            in: cookie
            name: JSESSIONID  # cookie name

    You can programmatically set the cookie:

conf = mailslurp_client.Configuration(
    api_key={'cookieAuth': 'abc123'}
    api_key_prefix={'cookieAuth': 'JSESSIONID'}
)

    The following cookie will be added to the HTTP request:
       Cookie: JSESSIONID abc123
    """

    _default = None

    def __init__(self, host="https://python.api.mailslurp.com",
                 api_key=None, api_key_prefix=None,
                 username=None, password=None,
                 discard_unknown_keys=False,
                 ):
        """Constructor
        """
        self.host = host
        """Default Base url
        """
        self.temp_folder_path = None
        """Temp file folder for downloading files
        """
        # Authentication Settings
        self.api_key = {}
        if api_key:
            self.api_key = api_key
        """dict to store API key(s)
        """
        self.api_key_prefix = {}
        if api_key_prefix:
            self.api_key_prefix = api_key_prefix
        """dict to store API prefix (e.g. Bearer)
        """
        self.refresh_api_key_hook = None
        """function hook to refresh API key if expired
        """
        self.username = username
        """Username for HTTP basic authentication
        """
        self.password = password
        """Password for HTTP basic authentication
        """
        self.discard_unknown_keys = discard_unknown_keys
        self.logger = {}
        """Logging Settings
        """
        self.logger["package_logger"] = logging.getLogger("mailslurp_client")
        self.logger["urllib3_logger"] = logging.getLogger("urllib3")
        self.logger_format = '%(asctime)s %(levelname)s %(message)s'
        """Log format
        """
        self.logger_stream_handler = None
        """Log stream handler
        """
        self.logger_file_handler = None
        """Log file handler
        """
        self.logger_file = None
        """Debug file location
        """
        self.debug = False
        """Debug switch
        """

        self.verify_ssl = True
        """SSL/TLS verification
           Set this to false to skip verifying SSL certificate when calling API
           from https server.
        """
        self.ssl_ca_cert = None
        """Set this to customize the certificate file to verify the peer.
        """
        self.cert_file = None
        """client certificate file
        """
        self.key_file = None
        """client key file
        """
        self.assert_hostname = None
        """Set this to True/False to enable/disable SSL hostname verification.
        """

        self.connection_pool_maxsize = multiprocessing.cpu_count() * 5
        """urllib3 connection pool's maximum number of connections saved
           per pool. urllib3 uses 1 connection as default value, but this is
           not the best value when you are making a lot of possibly parallel
           requests to the same host, which is often the case here.
           cpu_count * 5 is used as default value to increase performance.
        """

        self.proxy = None
        """Proxy URL
        """
        self.proxy_headers = None
        """Proxy headers
        """
        self.safe_chars_for_path_param = ''
        """Safe chars for path_param
        """
        self.retries = None
        """Adding retries to override urllib3 default value 3
        """
        # Disable client side validation
        self.client_side_validation = True

    def __deepcopy__(self, memo):
        cls = self.__class__
        result = cls.__new__(cls)
        memo[id(self)] = result
        for k, v in self.__dict__.items():
            if k not in ('logger', 'logger_file_handler'):
                setattr(result, k, copy.deepcopy(v, memo))
        # shallow copy of loggers
        result.logger = copy.copy(self.logger)
        # use setters to configure loggers
        result.logger_file = self.logger_file
        result.debug = self.debug
        return result

    def __setattr__(self, name, value):
        object.__setattr__(self, name, value)

    @classmethod
    def set_default(cls, default):
        """Set default instance of configuration.

        It stores default configuration, which can be
        returned by get_default_copy method.

        :param default: object of Configuration
        """
        cls._default = copy.deepcopy(default)

    @classmethod
    def get_default_copy(cls):
        """Return new instance of configuration.

        This method returns newly created, based on default constructor,
        object of Configuration class or returns a copy of default
        configuration passed by the set_default method.

        :return: The configuration object.
        """
        if cls._default is not None:
            return copy.deepcopy(cls._default)
        return Configuration()

    @property
    def logger_file(self):
        """The logger file.

        If the logger_file is None, then add stream handler and remove file
        handler. Otherwise, add file handler and remove stream handler.

        :param value: The logger_file path.
        :type: str
        """
        return self.__logger_file

    @logger_file.setter
    def logger_file(self, value):
        """The logger file.

        If the logger_file is None, then add stream handler and remove file
        handler. Otherwise, add file handler and remove stream handler.

        :param value: The logger_file path.
        :type: str
        """
        self.__logger_file = value
        if self.__logger_file:
            # If set logging file,
            # then add file handler and remove stream handler.
            self.logger_file_handler = logging.FileHandler(self.__logger_file)
            self.logger_file_handler.setFormatter(self.logger_formatter)
            for _, logger in six.iteritems(self.logger):
                logger.addHandler(self.logger_file_handler)

    @property
    def debug(self):
        """Debug status

        :param value: The debug status, True or False.
        :type: bool
        """
        return self.__debug

    @debug.setter
    def debug(self, value):
        """Debug status

        :param value: The debug status, True or False.
        :type: bool
        """
        self.__debug = value
        if self.__debug:
            # if debug status is True, turn on debug logging
            for _, logger in six.iteritems(self.logger):
                logger.setLevel(logging.DEBUG)
            # turn on httplib debug
            httplib.HTTPConnection.debuglevel = 1
        else:
            # if debug status is False, turn off debug logging,
            # setting log level to default `logging.WARNING`
            for _, logger in six.iteritems(self.logger):
                logger.setLevel(logging.WARNING)
            # turn off httplib debug
            httplib.HTTPConnection.debuglevel = 0

    @property
    def logger_format(self):
        """The logger format.

        The logger_formatter will be updated when sets logger_format.

        :param value: The format string.
        :type: str
        """
        return self.__logger_format

    @logger_format.setter
    def logger_format(self, value):
        """The logger format.

        The logger_formatter will be updated when sets logger_format.

        :param value: The format string.
        :type: str
        """
        self.__logger_format = value
        self.logger_formatter = logging.Formatter(self.__logger_format)

    def get_api_key_with_prefix(self, identifier):
        """Gets API key (with prefix if set).

        :param identifier: The identifier of apiKey.
        :return: The token for api key authentication.
        """
        if self.refresh_api_key_hook is not None:
            self.refresh_api_key_hook(self)
        key = self.api_key.get(identifier)
        if key:
            prefix = self.api_key_prefix.get(identifier)
            if prefix:
                return "%s %s" % (prefix, key)
            else:
                return key

    def get_basic_auth_token(self):
        """Gets HTTP basic authentication header (string).

        :return: The token for basic HTTP authentication.
        """
        username = ""
        if self.username is not None:
            username = self.username
        password = ""
        if self.password is not None:
            password = self.password
        return urllib3.util.make_headers(
            basic_auth=username + ':' + password
        ).get('authorization')

    def auth_settings(self):
        """Gets Auth Settings dict for api client.

        :return: The Auth Settings information dict.
        """
        auth = {}
        if 'x-api-key' in self.api_key:
            auth['API_KEY'] = {
                'type': 'api_key',
                'in': 'header',
                'key': 'x-api-key',
                'value': self.get_api_key_with_prefix('x-api-key')
            }
        return auth

    def to_debug_report(self):
        """Gets the essential information for debugging.

        :return: The report for debugging.
        """
        return "Python SDK Debug Report:\n"\
               "OS: {env}\n"\
               "Python Version: {pyversion}\n"\
               "Version of the API: 6.5.2\n"\
               "SDK Package Version: ".\
               format(env=sys.platform, pyversion=sys.version)

    def get_host_settings(self):
        """Gets an array of host settings

        :return: An array of host settings
        """
        return [
            {
                'url': "https://python.api.mailslurp.com",
                'description': "MailSlurp API Server",
            }
        ]

    def get_host_from_settings(self, index, variables=None):
        """Gets host URL based on the index and variables
        :param index: array index of the host settings
        :param variables: hash of variable and the corresponding value
        :return: URL based on host settings
        """
        variables = {} if variables is None else variables
        servers = self.get_host_settings()

        try:
            server = servers[index]
        except IndexError:
            raise ValueError(
                "Invalid index {0} when selecting the host settings. "
                "Must be less than {1}".format(index, len(servers)))

        url = server['url']

        # go through variables and replace placeholders
        for variable_name, variable in server['variables'].items():
            used_value = variables.get(
                variable_name, variable['default_value'])

            if 'enum_values' in variable \
                    and used_value not in variable['enum_values']:
                raise ValueError(
                    "The variable `{0}` in the host URL has invalid value "
                    "{1}. Must be {2}.".format(
                        variable_name, variables[variable_name],
                        variable['enum_values']))

            url = url.replace("{" + variable_name + "}", used_value)

        return url

mailslurp_client/api_client.py

# coding: utf-8
"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""

from __future__ import absolute_import

import atexit
import datetime
from dateutil.parser import parse
import json
import mimetypes
from multiprocessing.pool import ThreadPool
import os
import re
import tempfile

# python 2 and python 3 compatibility library
import six
from six.moves.urllib.parse import quote

from mailslurp_client.configuration import Configuration
import mailslurp_client.models
from mailslurp_client import rest
from mailslurp_client.exceptions import ApiValueError, ApiException


class ApiClient(object):
    """Generic API client for OpenAPI client library builds.

    OpenAPI generic API client. This client handles the client-
    server communication, and is invariant across implementations. Specifics of
    the methods and models for each application are generated from the OpenAPI
    templates.

    NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech
    Do not edit the class manually.

    :param configuration: .Configuration object for this client
    :param header_name: a header to pass when making calls to the API.
    :param header_value: a header value to pass when making calls to
        the API.
    :param cookie: a cookie to include in the header when making calls
        to the API
    :param pool_threads: The number of threads to use for async requests
        to the API. More threads means more concurrent API requests.
    """

    PRIMITIVE_TYPES = (float, bool, bytes, six.text_type) + six.integer_types
    NATIVE_TYPES_MAPPING = {
        'int': int,
        'long': int if six.PY3 else long,  # noqa: F821
        'float': float,
        'str': str,
        'bool': bool,
        'date': datetime.date,
        'datetime': datetime.datetime,
        'object': object,
    }
    _pool = None

    def __init__(self, configuration=None, header_name=None, header_value=None,
                 cookie=None, pool_threads=1):
        if configuration is None:
            configuration = Configuration.get_default_copy()
        self.configuration = configuration
        self.pool_threads = pool_threads

        self.rest_client = rest.RESTClientObject(configuration)
        self.default_headers = {}
        if header_name is not None:
            self.default_headers[header_name] = header_value
        self.cookie = cookie
        # Set default User-Agent.
        self.user_agent = 'OpenAPI-Generator//python'
        self.client_side_validation = configuration.client_side_validation

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        self.close()

    def close(self):
        if self._pool:
            self._pool.close()
            self._pool.join()
            self._pool = None
            if hasattr(atexit, 'unregister'):
                atexit.unregister(self.close)

    @property
    def pool(self):
        """Create thread pool on first request
         avoids instantiating unused threadpool for blocking clients.
        """
        if self._pool is None:
            atexit.register(self.close)
            self._pool = ThreadPool(self.pool_threads)
        return self._pool

    @property
    def user_agent(self):
        """User agent for this API client"""
        return self.default_headers['User-Agent']

    @user_agent.setter
    def user_agent(self, value):
        self.default_headers['User-Agent'] = value

    def set_default_header(self, header_name, header_value):
        self.default_headers[header_name] = header_value

    def __call_api(
            self, resource_path, method, path_params=None,
            query_params=None, header_params=None, body=None, post_params=None,
            files=None, response_type=None, auth_settings=None,
            _return_http_data_only=None, collection_formats=None,
            _preload_content=True, _request_timeout=None, _host=None):

        config = self.configuration

        # header parameters
        header_params = header_params or {}
        header_params.update(self.default_headers)
        if self.cookie:
            header_params['Cookie'] = self.cookie
        if header_params:
            header_params = self.sanitize_for_serialization(header_params)
            header_params = dict(self.parameters_to_tuples(header_params,
                                                           collection_formats))

        # path parameters
        if path_params:
            path_params = self.sanitize_for_serialization(path_params)
            path_params = self.parameters_to_tuples(path_params,
                                                    collection_formats)
            for k, v in path_params:
                # specified safe chars, encode everything
                resource_path = resource_path.replace(
                    '{%s}' % k,
                    quote(str(v), safe=config.safe_chars_for_path_param)
                )

        # query parameters
        if query_params:
            query_params = self.sanitize_for_serialization(query_params)
            query_params = self.parameters_to_tuples(query_params,
                                                     collection_formats)

        # post parameters
        if post_params or files:
            post_params = post_params if post_params else []
            post_params = self.sanitize_for_serialization(post_params)
            post_params = self.parameters_to_tuples(post_params,
                                                    collection_formats)
            post_params.extend(self.files_parameters(files))

        # auth setting
        self.update_params_for_auth(header_params, query_params, auth_settings)

        # body
        if body:
            body = self.sanitize_for_serialization(body)

        # request url
        if _host is None:
            url = self.configuration.host + resource_path
        else:
            # use server/host defined in path or operation instead
            url = _host + resource_path

        try:
            # perform request and return response
            response_data = self.request(
                method, url, query_params=query_params, headers=header_params,
                post_params=post_params, body=body,
                _preload_content=_preload_content,
                _request_timeout=_request_timeout)
        except ApiException as e:
            e.body = e.body.decode('utf-8') if six.PY3 else e.body
            raise e

        content_type = response_data.getheader('content-type')

        self.last_response = response_data

        return_data = response_data

        if not _preload_content:
            return return_data

        if six.PY3 and response_type not in ["file", "bytes"]:
            match = None
            if content_type is not None:
                match = re.search(r"charset=([a-zA-Z\-\d]+)[\s\;]?", content_type)
            encoding = match.group(1) if match else "utf-8"
            response_data.data = response_data.data.decode(encoding)

        # deserialize response data
        if response_type:
            return_data = self.deserialize(response_data, response_type)
        else:
            return_data = None

        if _return_http_data_only:
            return (return_data)
        else:
            return (return_data, response_data.status,
                    response_data.getheaders())

    def sanitize_for_serialization(self, obj):
        """Builds a JSON POST object.

        If obj is None, return None.
        If obj is str, int, long, float, bool, return directly.
        If obj is datetime.datetime, datetime.date
            convert to string in iso8601 format.
        If obj is list, sanitize each element in the list.
        If obj is dict, return the dict.
        If obj is OpenAPI model, return the properties dict.

        :param obj: The data to serialize.
        :return: The serialized form of data.
        """
        if obj is None:
            return None
        elif isinstance(obj, self.PRIMITIVE_TYPES):
            return obj
        elif isinstance(obj, list):
            return [self.sanitize_for_serialization(sub_obj)
                    for sub_obj in obj]
        elif isinstance(obj, tuple):
            return tuple(self.sanitize_for_serialization(sub_obj)
                         for sub_obj in obj)
        elif isinstance(obj, (datetime.datetime, datetime.date)):
            return obj.isoformat()

        if isinstance(obj, dict):
            obj_dict = obj
        else:
            # Convert model obj to dict except
            # attributes `openapi_types`, `attribute_map`
            # and attributes which value is not None.
            # Convert attribute name to json key in
            # model definition for request.
            obj_dict = {obj.attribute_map[attr]: getattr(obj, attr)
                        for attr, _ in six.iteritems(obj.openapi_types)
                        if getattr(obj, attr) is not None}

        return {key: self.sanitize_for_serialization(val)
                for key, val in six.iteritems(obj_dict)}

    def deserialize(self, response, response_type):
        """Deserializes response into an object.

        :param response: RESTResponse object to be deserialized.
        :param response_type: class literal for
            deserialized object, or string of class name.

        :return: deserialized object.
        """
        # handle file downloading
        # save response body into a tmp file and return the instance
        if response_type == "file":
            return self.__deserialize_file(response)

        # fetch data from response object
        try:
            data = json.loads(response.data)
        except ValueError:
            data = response.data

        return self.__deserialize(data, response_type)

    def __deserialize(self, data, klass):
        """Deserializes dict, list, str into an object.

        :param data: dict, list or str.
        :param klass: class literal, or string of class name.

        :return: object.
        """
        if data is None:
            return None

        if type(klass) == str:
            if klass.startswith('list['):
                sub_kls = re.match(r'list\[(.*)\]', klass).group(1)
                return [self.__deserialize(sub_data, sub_kls)
                        for sub_data in data]

            if klass.startswith('dict('):
                sub_kls = re.match(r'dict\(([^,]*), (.*)\)', klass).group(2)
                return {k: self.__deserialize(v, sub_kls)
                        for k, v in six.iteritems(data)}

            # convert str to class
            if klass in self.NATIVE_TYPES_MAPPING:
                klass = self.NATIVE_TYPES_MAPPING[klass]
            else:
                klass = getattr(mailslurp_client.models, klass)

        if klass in self.PRIMITIVE_TYPES:
            return self.__deserialize_primitive(data, klass)
        elif klass == object:
            return self.__deserialize_object(data)
        elif klass == datetime.date:
            return self.__deserialize_date(data)
        elif klass == datetime.datetime:
            return self.__deserialize_datetime(data)
        else:
            return self.__deserialize_model(data, klass)

    def call_api(self, resource_path, method,
                 path_params=None, query_params=None, header_params=None,
                 body=None, post_params=None, files=None,
                 response_type=None, auth_settings=None, async_req=None,
                 _return_http_data_only=None, collection_formats=None,
                 _preload_content=True, _request_timeout=None, _host=None):
        """Makes the HTTP request (synchronous) and returns deserialized data.

        To make an async_req request, set the async_req parameter.

        :param resource_path: Path to method endpoint.
        :param method: Method to call.
        :param path_params: Path parameters in the url.
        :param query_params: Query parameters in the url.
        :param header_params: Header parameters to be
            placed in the request header.
        :param body: Request body.
        :param post_params dict: Request post form parameters,
            for `application/x-www-form-urlencoded`, `multipart/form-data`.
        :param auth_settings list: Auth Settings names for the request.
        :param response: Response data type.
        :param files dict: key -> filename, value -> filepath,
            for `multipart/form-data`.
        :param async_req bool: execute request asynchronously
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param collection_formats: dict of collection formats for path, query,
            header, and post parameters.
        :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:
            If async_req parameter is True,
            the request will be called asynchronously.
            The method will return the request thread.
            If parameter async_req is False or missing,
            then the method will return the response directly.
        """
        if not async_req:
            return self.__call_api(resource_path, method,
                                   path_params, query_params, header_params,
                                   body, post_params, files,
                                   response_type, auth_settings,
                                   _return_http_data_only, collection_formats,
                                   _preload_content, _request_timeout, _host)

        return self.pool.apply_async(self.__call_api, (resource_path,
                                                       method, path_params,
                                                       query_params,
                                                       header_params, body,
                                                       post_params, files,
                                                       response_type,
                                                       auth_settings,
                                                       _return_http_data_only,
                                                       collection_formats,
                                                       _preload_content,
                                                       _request_timeout,
                                                       _host))

    def request(self, method, url, query_params=None, headers=None,
                post_params=None, body=None, _preload_content=True,
                _request_timeout=None):
        """Makes the HTTP request using RESTClient."""
        if method == "GET":
            return self.rest_client.GET(url,
                                        query_params=query_params,
                                        _preload_content=_preload_content,
                                        _request_timeout=_request_timeout,
                                        headers=headers)
        elif method == "HEAD":
            return self.rest_client.HEAD(url,
                                         query_params=query_params,
                                         _preload_content=_preload_content,
                                         _request_timeout=_request_timeout,
                                         headers=headers)
        elif method == "OPTIONS":
            return self.rest_client.OPTIONS(url,
                                            query_params=query_params,
                                            headers=headers,
                                            _preload_content=_preload_content,
                                            _request_timeout=_request_timeout)
        elif method == "POST":
            return self.rest_client.POST(url,
                                         query_params=query_params,
                                         headers=headers,
                                         post_params=post_params,
                                         _preload_content=_preload_content,
                                         _request_timeout=_request_timeout,
                                         body=body)
        elif method == "PUT":
            return self.rest_client.PUT(url,
                                        query_params=query_params,
                                        headers=headers,
                                        post_params=post_params,
                                        _preload_content=_preload_content,
                                        _request_timeout=_request_timeout,
                                        body=body)
        elif method == "PATCH":
            return self.rest_client.PATCH(url,
                                          query_params=query_params,
                                          headers=headers,
                                          post_params=post_params,
                                          _preload_content=_preload_content,
                                          _request_timeout=_request_timeout,
                                          body=body)
        elif method == "DELETE":
            return self.rest_client.DELETE(url,
                                           query_params=query_params,
                                           headers=headers,
                                           _preload_content=_preload_content,
                                           _request_timeout=_request_timeout,
                                           body=body)
        else:
            raise ApiValueError(
                "http method must be `GET`, `HEAD`, `OPTIONS`,"
                " `POST`, `PATCH`, `PUT` or `DELETE`."
            )

    def parameters_to_tuples(self, params, collection_formats):
        """Get parameters as list of tuples, formatting collections.

        :param params: Parameters as dict or list of two-tuples
        :param dict collection_formats: Parameter collection formats
        :return: Parameters as list of tuples, collections formatted
        """
        new_params = []
        if collection_formats is None:
            collection_formats = {}
        for k, v in six.iteritems(params) if isinstance(params, dict) else params:  # noqa: E501
            if k in collection_formats:
                collection_format = collection_formats[k]
                if collection_format == 'multi':
                    new_params.extend((k, value) for value in v)
                else:
                    if collection_format == 'ssv':
                        delimiter = ' '
                    elif collection_format == 'tsv':
                        delimiter = '\t'
                    elif collection_format == 'pipes':
                        delimiter = '|'
                    else:  # csv is the default
                        delimiter = ','
                    new_params.append(
                        (k, delimiter.join(str(value) for value in v)))
            else:
                new_params.append((k, v))
        return new_params

    def files_parameters(self, files=None):
        """Builds form parameters.

        :param files: File parameters.
        :return: Form parameters with files.
        """
        params = []

        if files:
            for k, v in six.iteritems(files):
                if not v:
                    continue
                file_names = v if type(v) is list else [v]
                for n in file_names:
                    with open(n, 'rb') as f:
                        filename = os.path.basename(f.name)
                        filedata = f.read()
                        mimetype = (mimetypes.guess_type(filename)[0] or
                                    'application/octet-stream')
                        params.append(
                            tuple([k, tuple([filename, filedata, mimetype])]))

        return params

    def select_header_accept(self, accepts):
        """Returns `Accept` based on an array of accepts provided.

        :param accepts: List of headers.
        :return: Accept (e.g. application/json).
        """
        if not accepts:
            return

        accepts = [x.lower() for x in accepts]

        if 'application/json' in accepts:
            return 'application/json'
        else:
            return ', '.join(accepts)

    def select_header_content_type(self, content_types):
        """Returns `Content-Type` based on an array of content_types provided.

        :param content_types: List of content-types.
        :return: Content-Type (e.g. application/json).
        """
        if not content_types:
            return 'application/json'

        content_types = [x.lower() for x in content_types]

        if 'application/json' in content_types or '*/*' in content_types:
            return 'application/json'
        else:
            return content_types[0]

    def update_params_for_auth(self, headers, querys, auth_settings):
        """Updates header and query params based on authentication setting.

        :param headers: Header parameters dict to be updated.
        :param querys: Query parameters tuple list to be updated.
        :param auth_settings: Authentication setting identifiers list.
        """
        if not auth_settings:
            return

        for auth in auth_settings:
            auth_setting = self.configuration.auth_settings().get(auth)
            if auth_setting:
                if auth_setting['in'] == 'cookie':
                    headers['Cookie'] = auth_setting['value']
                elif auth_setting['in'] == 'header':
                    headers[auth_setting['key']] = auth_setting['value']
                elif auth_setting['in'] == 'query':
                    querys.append((auth_setting['key'], auth_setting['value']))
                else:
                    raise ApiValueError(
                        'Authentication token must be in `query` or `header`'
                    )

    def __deserialize_file(self, response):
        """Deserializes body to file

        Saves response body into a file in a temporary folder,
        using the filename from the `Content-Disposition` header if provided.

        :param response:  RESTResponse.
        :return: file path.
        """
        fd, path = tempfile.mkstemp(dir=self.configuration.temp_folder_path)
        os.close(fd)
        os.remove(path)

        content_disposition = response.getheader("Content-Disposition")
        if content_disposition:
            filename = re.search(r'filename=[\'"]?([^\'"\s]+)[\'"]?',
                                 content_disposition).group(1)
            path = os.path.join(os.path.dirname(path), filename)

        with open(path, "wb") as f:
            f.write(response.data)

        return path

    def __deserialize_primitive(self, data, klass):
        """Deserializes string to primitive type.

        :param data: str.
        :param klass: class literal.

        :return: int, long, float, str, bool.
        """
        try:
            return klass(data)
        except UnicodeEncodeError:
            return six.text_type(data)
        except TypeError:
            return data

    def __deserialize_object(self, value):
        """Return an original value.

        :return: object.
        """
        return value

    def __deserialize_date(self, string):
        """Deserializes string to date.

        :param string: str.
        :return: date.
        """
        try:
            return parse(string).date()
        except ImportError:
            return string
        except ValueError:
            raise rest.ApiException(
                status=0,
                reason="Failed to parse `{0}` as date object".format(string)
            )

    def __deserialize_datetime(self, string):
        """Deserializes string to datetime.

        The string should be in iso8601 datetime format.

        :param string: str.
        :return: datetime.
        """
        try:
            return parse(string)
        except ImportError:
            return string
        except ValueError:
            raise rest.ApiException(
                status=0,
                reason=(
                    "Failed to parse `{0}` as datetime object"
                    .format(string)
                )
            )

    def __deserialize_model(self, data, klass):
        """Deserializes list or dict to model.

        :param data: dict, list.
        :param klass: class literal.
        :return: model object.
        """
        has_discriminator = False
        if (hasattr(klass, 'get_real_child_model')
                and klass.discriminator_value_class_map):
            has_discriminator = True

        if not klass.openapi_types and has_discriminator is False:
            return data

        kwargs = {}
        if (data is not None and
                klass.openapi_types is not None and
                isinstance(data, (list, dict))):
            for attr, attr_type in six.iteritems(klass.openapi_types):
                if klass.attribute_map[attr] in data:
                    value = data[klass.attribute_map[attr]]
                    kwargs[attr] = self.__deserialize(value, attr_type)

        instance = klass(**kwargs)

        if has_discriminator:
            klass_name = instance.get_real_child_model(data)
            if klass_name:
                instance = self.__deserialize(data, klass_name)
        return instance

mailslurp_client/__init__.py

# coding: utf-8

# flake8: noqa

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

__version__ = ""

# import apis into sdk package
from mailslurp_client.api.alias_controller_api import AliasControllerApi
from mailslurp_client.api.attachment_controller_api import AttachmentControllerApi
from mailslurp_client.api.bounce_controller_api import BounceControllerApi
from mailslurp_client.api.bulk_actions_controller_api import BulkActionsControllerApi
from mailslurp_client.api.common_actions_controller_api import CommonActionsControllerApi
from mailslurp_client.api.connector_controller_api import ConnectorControllerApi
from mailslurp_client.api.contact_controller_api import ContactControllerApi
from mailslurp_client.api.domain_controller_api import DomainControllerApi
from mailslurp_client.api.email_controller_api import EmailControllerApi
from mailslurp_client.api.email_verification_controller_api import EmailVerificationControllerApi
from mailslurp_client.api.expired_controller_api import ExpiredControllerApi
from mailslurp_client.api.export_controller_api import ExportControllerApi
from mailslurp_client.api.form_controller_api import FormControllerApi
from mailslurp_client.api.group_controller_api import GroupControllerApi
from mailslurp_client.api.imap_controller_api import ImapControllerApi
from mailslurp_client.api.inbox_controller_api import InboxControllerApi
from mailslurp_client.api.inbox_forwarder_controller_api import InboxForwarderControllerApi
from mailslurp_client.api.inbox_replier_controller_api import InboxReplierControllerApi
from mailslurp_client.api.inbox_ruleset_controller_api import InboxRulesetControllerApi
from mailslurp_client.api.mail_server_controller_api import MailServerControllerApi
from mailslurp_client.api.missed_email_controller_api import MissedEmailControllerApi
from mailslurp_client.api.phone_controller_api import PhoneControllerApi
from mailslurp_client.api.sent_emails_controller_api import SentEmailsControllerApi
from mailslurp_client.api.sms_controller_api import SmsControllerApi
from mailslurp_client.api.template_controller_api import TemplateControllerApi
from mailslurp_client.api.tools_controller_api import ToolsControllerApi
from mailslurp_client.api.tracking_controller_api import TrackingControllerApi
from mailslurp_client.api.user_controller_api import UserControllerApi
from mailslurp_client.api.wait_for_controller_api import WaitForControllerApi
from mailslurp_client.api.webhook_controller_api import WebhookControllerApi

# import ApiClient
from mailslurp_client.api_client import ApiClient
from mailslurp_client.configuration import Configuration
from mailslurp_client.exceptions import OpenApiException
from mailslurp_client.exceptions import ApiTypeError
from mailslurp_client.exceptions import ApiValueError
from mailslurp_client.exceptions import ApiKeyError
from mailslurp_client.exceptions import ApiException
# import models into sdk package
from mailslurp_client.models.abstract_webhook_payload import AbstractWebhookPayload
from mailslurp_client.models.account_bounce_block_dto import AccountBounceBlockDto
from mailslurp_client.models.alias_dto import AliasDto
from mailslurp_client.models.alias_projection import AliasProjection
from mailslurp_client.models.attachment_entity import AttachmentEntity
from mailslurp_client.models.attachment_meta_data import AttachmentMetaData
from mailslurp_client.models.attachment_projection import AttachmentProjection
from mailslurp_client.models.basic_auth_options import BasicAuthOptions
from mailslurp_client.models.bounce_projection import BounceProjection
from mailslurp_client.models.bounce_recipient_projection import BounceRecipientProjection
from mailslurp_client.models.bounced_email_dto import BouncedEmailDto
from mailslurp_client.models.bounced_recipient_dto import BouncedRecipientDto
from mailslurp_client.models.bulk_send_email_options import BulkSendEmailOptions
from mailslurp_client.models.can_send_email_results import CanSendEmailResults
from mailslurp_client.models.check_email_body_feature_support_results import CheckEmailBodyFeatureSupportResults
from mailslurp_client.models.check_email_body_results import CheckEmailBodyResults
from mailslurp_client.models.check_email_client_support_options import CheckEmailClientSupportOptions
from mailslurp_client.models.check_email_client_support_results import CheckEmailClientSupportResults
from mailslurp_client.models.check_email_features_client_support_options import CheckEmailFeaturesClientSupportOptions
from mailslurp_client.models.check_email_features_client_support_results import CheckEmailFeaturesClientSupportResults
from mailslurp_client.models.complaint import Complaint
from mailslurp_client.models.condition_option import ConditionOption
from mailslurp_client.models.connector_dto import ConnectorDto
from mailslurp_client.models.connector_imap_connection_dto import ConnectorImapConnectionDto
from mailslurp_client.models.connector_projection import ConnectorProjection
from mailslurp_client.models.connector_smtp_connection_dto import ConnectorSmtpConnectionDto
from mailslurp_client.models.connector_sync_event_dto import ConnectorSyncEventDto
from mailslurp_client.models.connector_sync_event_projection import ConnectorSyncEventProjection
from mailslurp_client.models.connector_sync_request_result import ConnectorSyncRequestResult
from mailslurp_client.models.connector_sync_request_result_exception import ConnectorSyncRequestResultException
from mailslurp_client.models.connector_sync_request_result_exception_cause import ConnectorSyncRequestResultExceptionCause
from mailslurp_client.models.connector_sync_request_result_exception_cause_stack_trace import ConnectorSyncRequestResultExceptionCauseStackTrace
from mailslurp_client.models.connector_sync_result import ConnectorSyncResult
from mailslurp_client.models.contact_dto import ContactDto
from mailslurp_client.models.contact_projection import ContactProjection
from mailslurp_client.models.content_match_options import ContentMatchOptions
from mailslurp_client.models.count_dto import CountDto
from mailslurp_client.models.create_alias_options import CreateAliasOptions
from mailslurp_client.models.create_connector_imap_connection_options import CreateConnectorImapConnectionOptions
from mailslurp_client.models.create_connector_options import CreateConnectorOptions
from mailslurp_client.models.create_connector_smtp_connection_options import CreateConnectorSmtpConnectionOptions
from mailslurp_client.models.create_contact_options import CreateContactOptions
from mailslurp_client.models.create_domain_options import CreateDomainOptions
from mailslurp_client.models.create_emergency_address_options import CreateEmergencyAddressOptions
from mailslurp_client.models.create_group_options import CreateGroupOptions
from mailslurp_client.models.create_inbox_dto import CreateInboxDto
from mailslurp_client.models.create_inbox_forwarder_options import CreateInboxForwarderOptions
from mailslurp_client.models.create_inbox_replier_options import CreateInboxReplierOptions
from mailslurp_client.models.create_inbox_ruleset_options import CreateInboxRulesetOptions
from mailslurp_client.models.create_template_options import CreateTemplateOptions
from mailslurp_client.models.create_tracking_pixel_options import CreateTrackingPixelOptions
from mailslurp_client.models.create_webhook_options import CreateWebhookOptions
from mailslurp_client.models.dns_lookup_options import DNSLookupOptions
from mailslurp_client.models.dns_lookup_result import DNSLookupResult
from mailslurp_client.models.dns_lookup_results import DNSLookupResults
from mailslurp_client.models.dns_lookups_options import DNSLookupsOptions
from mailslurp_client.models.delivery_status_dto import DeliveryStatusDto
from mailslurp_client.models.describe_domain_options import DescribeDomainOptions
from mailslurp_client.models.describe_mail_server_domain_result import DescribeMailServerDomainResult
from mailslurp_client.models.domain_dto import DomainDto
from mailslurp_client.models.domain_group import DomainGroup
from mailslurp_client.models.domain_groups_dto import DomainGroupsDto
from mailslurp_client.models.domain_information import DomainInformation
from mailslurp_client.models.domain_issues_dto import DomainIssuesDto
from mailslurp_client.models.domain_name_record import DomainNameRecord
from mailslurp_client.models.domain_preview import DomainPreview
from mailslurp_client.models.download_attachment_dto import DownloadAttachmentDto
from mailslurp_client.models.email import Email
from mailslurp_client.models.email_analysis import EmailAnalysis
from mailslurp_client.models.email_available_result import EmailAvailableResult
from mailslurp_client.models.email_content_match_result import EmailContentMatchResult
from mailslurp_client.models.email_content_part_result import EmailContentPartResult
from mailslurp_client.models.email_feature_category_name import EmailFeatureCategoryName
from mailslurp_client.models.email_feature_family_name import EmailFeatureFamilyName
from mailslurp_client.models.email_feature_family_statistics import EmailFeatureFamilyStatistics
from mailslurp_client.models.email_feature_names import EmailFeatureNames
from mailslurp_client.models.email_feature_overview import EmailFeatureOverview
from mailslurp_client.models.email_feature_platform_name import EmailFeaturePlatformName
from mailslurp_client.models.email_feature_platform_statistics import EmailFeaturePlatformStatistics
from mailslurp_client.models.email_feature_support_flags import EmailFeatureSupportFlags
from mailslurp_client.models.email_feature_support_result import EmailFeatureSupportResult
from mailslurp_client.models.email_feature_support_status_percentage import EmailFeatureSupportStatusPercentage
from mailslurp_client.models.email_feature_version_statistics import EmailFeatureVersionStatistics
from mailslurp_client.models.email_html_dto import EmailHtmlDto
from mailslurp_client.models.email_links_result import EmailLinksResult
from mailslurp_client.models.email_preview import EmailPreview
from mailslurp_client.models.email_preview_urls import EmailPreviewUrls
from mailslurp_client.models.email_projection import EmailProjection
from mailslurp_client.models.email_recipients import EmailRecipients
from mailslurp_client.models.email_screenshot_result import EmailScreenshotResult
from mailslurp_client.models.email_text_lines_result import EmailTextLinesResult
from mailslurp_client.models.email_validation_request_dto import EmailValidationRequestDto
from mailslurp_client.models.email_verification_result import EmailVerificationResult
from mailslurp_client.models.emergency_address import EmergencyAddress
from mailslurp_client.models.emergency_address_dto import EmergencyAddressDto
from mailslurp_client.models.empty_response_dto import EmptyResponseDto
from mailslurp_client.models.expiration_defaults import ExpirationDefaults
from mailslurp_client.models.expired_inbox_dto import ExpiredInboxDto
from mailslurp_client.models.expired_inbox_record_projection import ExpiredInboxRecordProjection
from mailslurp_client.models.export_link import ExportLink
from mailslurp_client.models.export_options import ExportOptions
from mailslurp_client.models.fake_email_dto import FakeEmailDto
from mailslurp_client.models.fake_email_preview import FakeEmailPreview
from mailslurp_client.models.fake_email_result import FakeEmailResult
from mailslurp_client.models.filter_bounced_recipients_options import FilterBouncedRecipientsOptions
from mailslurp_client.models.filter_bounced_recipients_result import FilterBouncedRecipientsResult
from mailslurp_client.models.flush_expired_inboxes_result import FlushExpiredInboxesResult
from mailslurp_client.models.forward_email_options import ForwardEmailOptions
from mailslurp_client.models.generate_bimi_record_options import GenerateBimiRecordOptions
from mailslurp_client.models.generate_bimi_record_results import GenerateBimiRecordResults
from mailslurp_client.models.generate_dmarc_record_options import GenerateDmarcRecordOptions
from mailslurp_client.models.generate_dmarc_record_results import GenerateDmarcRecordResults
from mailslurp_client.models.generate_mta_sts_record_options import GenerateMtaStsRecordOptions
from mailslurp_client.models.generate_mta_sts_record_results import GenerateMtaStsRecordResults
from mailslurp_client.models.generate_tls_reporting_record_options import GenerateTlsReportingRecordOptions
from mailslurp_client.models.generate_tls_reporting_record_results import GenerateTlsReportingRecordResults
from mailslurp_client.models.get_email_screenshot_options import GetEmailScreenshotOptions
from mailslurp_client.models.gravatar_url import GravatarUrl
from mailslurp_client.models.group_contacts_dto import GroupContactsDto
from mailslurp_client.models.group_dto import GroupDto
from mailslurp_client.models.group_projection import GroupProjection
from mailslurp_client.models.html_validation_result import HTMLValidationResult
from mailslurp_client.models.ip_address_result import IPAddressResult
from mailslurp_client.models.image_issue import ImageIssue
from mailslurp_client.models.imap_access_details import ImapAccessDetails
from mailslurp_client.models.imap_email_projection import ImapEmailProjection
from mailslurp_client.models.imap_flag_operation_options import ImapFlagOperationOptions
from mailslurp_client.models.imap_mailbox_status import ImapMailboxStatus
from mailslurp_client.models.imap_server_fetch_item import ImapServerFetchItem
from mailslurp_client.models.imap_server_fetch_result import ImapServerFetchResult
from mailslurp_client.models.imap_server_get_result import ImapServerGetResult
from mailslurp_client.models.imap_server_list_options import ImapServerListOptions
from mailslurp_client.models.imap_server_list_result import ImapServerListResult
from mailslurp_client.models.imap_server_mailbox_result import ImapServerMailboxResult
from mailslurp_client.models.imap_server_search_options import ImapServerSearchOptions
from mailslurp_client.models.imap_server_search_result import ImapServerSearchResult
from mailslurp_client.models.imap_server_status_options import ImapServerStatusOptions
from mailslurp_client.models.imap_server_status_result import ImapServerStatusResult
from mailslurp_client.models.imap_smtp_access_details import ImapSmtpAccessDetails
from mailslurp_client.models.imap_smtp_access_servers import ImapSmtpAccessServers
from mailslurp_client.models.imap_update_flags_options import ImapUpdateFlagsOptions
from mailslurp_client.models.inbox_by_email_address_result import InboxByEmailAddressResult
from mailslurp_client.models.inbox_by_name_result import InboxByNameResult
from mailslurp_client.models.inbox_dto import InboxDto
from mailslurp_client.models.inbox_exists_dto import InboxExistsDto
from mailslurp_client.models.inbox_forwarder_dto import InboxForwarderDto
from mailslurp_client.models.inbox_forwarder_event_dto import InboxForwarderEventDto
from mailslurp_client.models.inbox_forwarder_event_projection import InboxForwarderEventProjection
from mailslurp_client.models.inbox_forwarder_test_options import InboxForwarderTestOptions
from mailslurp_client.models.inbox_forwarder_test_result import InboxForwarderTestResult
from mailslurp_client.models.inbox_id_item import InboxIdItem
from mailslurp_client.models.inbox_ids_result import InboxIdsResult
from mailslurp_client.models.inbox_preview import InboxPreview
from mailslurp_client.models.inbox_replier_dto import InboxReplierDto
from mailslurp_client.models.inbox_replier_event_projection import InboxReplierEventProjection
from mailslurp_client.models.inbox_ruleset_dto import InboxRulesetDto
from mailslurp_client.models.inbox_ruleset_test_options import InboxRulesetTestOptions
from mailslurp_client.models.inbox_ruleset_test_result import InboxRulesetTestResult
from mailslurp_client.models.inline_object import InlineObject
from mailslurp_client.models.json_schema_dto import JSONSchemaDto
from mailslurp_client.models.link_issue import LinkIssue
from mailslurp_client.models.list_unsubscribe_recipient_projection import ListUnsubscribeRecipientProjection
from mailslurp_client.models.lookup_bimi_domain_options import LookupBimiDomainOptions
from mailslurp_client.models.lookup_bimi_domain_results import LookupBimiDomainResults
from mailslurp_client.models.lookup_dmarc_domain_options import LookupDmarcDomainOptions
from mailslurp_client.models.lookup_dmarc_domain_results import LookupDmarcDomainResults
from mailslurp_client.models.lookup_mta_sts_domain_options import LookupMtaStsDomainOptions
from mailslurp_client.models.lookup_mta_sts_domain_results import LookupMtaStsDomainResults
from mailslurp_client.models.lookup_tls_reporting_domain_options import LookupTlsReportingDomainOptions
from mailslurp_client.models.lookup_tls_reporting_domain_results import LookupTlsReportingDomainResults
from mailslurp_client.models.match_option import MatchOption
from mailslurp_client.models.match_options import MatchOptions
from mailslurp_client.models.missed_email_dto import MissedEmailDto
from mailslurp_client.models.missed_email_projection import MissedEmailProjection
from mailslurp_client.models.name_server_record import NameServerRecord
from mailslurp_client.models.new_fake_email_address_result import NewFakeEmailAddressResult
from mailslurp_client.models.organization_inbox_projection import OrganizationInboxProjection
from mailslurp_client.models.page_alias import PageAlias
from mailslurp_client.models.page_attachment_entity import PageAttachmentEntity
from mailslurp_client.models.page_bounced_email import PageBouncedEmail
from mailslurp_client.models.page_bounced_recipients import PageBouncedRecipients
from mailslurp_client.models.page_complaint import PageComplaint
from mailslurp_client.models.page_connector import PageConnector
from mailslurp_client.models.page_connector_sync_events import PageConnectorSyncEvents
from mailslurp_client.models.page_contact_projection import PageContactProjection
from mailslurp_client.models.page_delivery_status import PageDeliveryStatus
from mailslurp_client.models.page_email_preview import PageEmailPreview
from mailslurp_client.models.page_email_projection import PageEmailProjection
from mailslurp_client.models.page_email_validation_request import PageEmailValidationRequest
from mailslurp_client.models.page_expired_inbox_record_projection import PageExpiredInboxRecordProjection
from mailslurp_client.models.page_group_projection import PageGroupProjection
from mailslurp_client.models.page_inbox_forwarder_dto import PageInboxForwarderDto
from mailslurp_client.models.page_inbox_forwarder_events import PageInboxForwarderEvents
from mailslurp_client.models.page_inbox_projection import PageInboxProjection
from mailslurp_client.models.page_inbox_replier_dto import PageInboxReplierDto
from mailslurp_client.models.page_inbox_replier_events import PageInboxReplierEvents
from mailslurp_client.models.page_inbox_ruleset_dto import PageInboxRulesetDto
from mailslurp_client.models.page_list_unsubscribe_recipients import PageListUnsubscribeRecipients
from mailslurp_client.models.page_missed_email_projection import PageMissedEmailProjection
from mailslurp_client.models.page_organization_inbox_projection import PageOrganizationInboxProjection
from mailslurp_client.models.page_phone_number_projection import PagePhoneNumberProjection
from mailslurp_client.models.page_scheduled_jobs import PageScheduledJobs
from mailslurp_client.models.page_sent_email_projection import PageSentEmailProjection
from mailslurp_client.models.page_sent_email_with_queue_projection import PageSentEmailWithQueueProjection
from mailslurp_client.models.page_sms_projection import PageSmsProjection
from mailslurp_client.models.page_template_projection import PageTemplateProjection
from mailslurp_client.models.page_thread_projection import PageThreadProjection
from mailslurp_client.models.page_tracking_pixel_projection import PageTrackingPixelProjection
from mailslurp_client.models.page_unknown_missed_email_projection import PageUnknownMissedEmailProjection
from mailslurp_client.models.page_webhook_projection import PageWebhookProjection
from mailslurp_client.models.page_webhook_result import PageWebhookResult
from mailslurp_client.models.pageable_object import PageableObject
from mailslurp_client.models.phone_number_dto import PhoneNumberDto
from mailslurp_client.models.phone_number_projection import PhoneNumberProjection
from mailslurp_client.models.phone_plan_dto import PhonePlanDto
from mailslurp_client.models.raw_email_json import RawEmailJson
from mailslurp_client.models.recipient import Recipient
from mailslurp_client.models.reply_for_sms import ReplyForSms
from mailslurp_client.models.reply_to_alias_email_options import ReplyToAliasEmailOptions
from mailslurp_client.models.reply_to_email_options import ReplyToEmailOptions
from mailslurp_client.models.scheduled_job import ScheduledJob
from mailslurp_client.models.scheduled_job_dto import ScheduledJobDto
from mailslurp_client.models.search_emails_options import SearchEmailsOptions
from mailslurp_client.models.search_inboxes_options import SearchInboxesOptions
from mailslurp_client.models.send_email_body_part import SendEmailBodyPart
from mailslurp_client.models.send_email_options import SendEmailOptions
from mailslurp_client.models.send_smtp_envelope_options import SendSMTPEnvelopeOptions
from mailslurp_client.models.send_with_queue_result import SendWithQueueResult
from mailslurp_client.models.sender import Sender
from mailslurp_client.models.sent_email_dto import SentEmailDto
from mailslurp_client.models.sent_email_projection import SentEmailProjection
from mailslurp_client.models.sent_sms_dto import SentSmsDto
from mailslurp_client.models.server_endpoints import ServerEndpoints
from mailslurp_client.models.set_inbox_favourited_options import SetInboxFavouritedOptions
from mailslurp_client.models.simple_send_email_options import SimpleSendEmailOptions
from mailslurp_client.models.sms_dto import SmsDto
from mailslurp_client.models.sms_match_option import SmsMatchOption
from mailslurp_client.models.sms_preview import SmsPreview
from mailslurp_client.models.sms_projection import SmsProjection
from mailslurp_client.models.sms_reply_options import SmsReplyOptions
from mailslurp_client.models.smtp_access_details import SmtpAccessDetails
from mailslurp_client.models.sort_object import SortObject
from mailslurp_client.models.spelling_issue import SpellingIssue
from mailslurp_client.models.template_dto import TemplateDto
from mailslurp_client.models.template_preview import TemplatePreview
from mailslurp_client.models.template_projection import TemplateProjection
from mailslurp_client.models.template_variable import TemplateVariable
from mailslurp_client.models.test_inbox_ruleset_receiving_options import TestInboxRulesetReceivingOptions
from mailslurp_client.models.test_inbox_ruleset_receiving_result import TestInboxRulesetReceivingResult
from mailslurp_client.models.test_inbox_ruleset_sending_options import TestInboxRulesetSendingOptions
from mailslurp_client.models.test_inbox_ruleset_sending_result import TestInboxRulesetSendingResult
from mailslurp_client.models.test_new_inbox_forwarder_options import TestNewInboxForwarderOptions
from mailslurp_client.models.test_new_inbox_ruleset_options import TestNewInboxRulesetOptions
from mailslurp_client.models.test_phone_number_options import TestPhoneNumberOptions
from mailslurp_client.models.thread_projection import ThreadProjection
from mailslurp_client.models.tracking_pixel_dto import TrackingPixelDto
from mailslurp_client.models.tracking_pixel_projection import TrackingPixelProjection
from mailslurp_client.models.unknown_missed_email_projection import UnknownMissedEmailProjection
from mailslurp_client.models.unread_count import UnreadCount
from mailslurp_client.models.unseen_error_count_dto import UnseenErrorCountDto
from mailslurp_client.models.update_alias_options import UpdateAliasOptions
from mailslurp_client.models.update_domain_options import UpdateDomainOptions
from mailslurp_client.models.update_group_contacts import UpdateGroupContacts
from mailslurp_client.models.update_imap_access_options import UpdateImapAccessOptions
from mailslurp_client.models.update_inbox_options import UpdateInboxOptions
from mailslurp_client.models.update_inbox_replier_options import UpdateInboxReplierOptions
from mailslurp_client.models.update_smtp_access_options import UpdateSmtpAccessOptions
from mailslurp_client.models.upload_attachment_options import UploadAttachmentOptions
from mailslurp_client.models.user_info_dto import UserInfoDto
from mailslurp_client.models.validate_email_address_list_options import ValidateEmailAddressListOptions
from mailslurp_client.models.validate_email_address_list_result import ValidateEmailAddressListResult
from mailslurp_client.models.validation_dto import ValidationDto
from mailslurp_client.models.validation_message import ValidationMessage
from mailslurp_client.models.verify_email_address_options import VerifyEmailAddressOptions
from mailslurp_client.models.verify_webhook_signature_options import VerifyWebhookSignatureOptions
from mailslurp_client.models.verify_webhook_signature_results import VerifyWebhookSignatureResults
from mailslurp_client.models.wait_for_conditions import WaitForConditions
from mailslurp_client.models.wait_for_single_sms_options import WaitForSingleSmsOptions
from mailslurp_client.models.wait_for_sms_conditions import WaitForSmsConditions
from mailslurp_client.models.webhook_bounce_payload import WebhookBouncePayload
from mailslurp_client.models.webhook_bounce_recipient_payload import WebhookBounceRecipientPayload
from mailslurp_client.models.webhook_delivery_status_payload import WebhookDeliveryStatusPayload
from mailslurp_client.models.webhook_dto import WebhookDto
from mailslurp_client.models.webhook_email_opened_payload import WebhookEmailOpenedPayload
from mailslurp_client.models.webhook_email_read_payload import WebhookEmailReadPayload
from mailslurp_client.models.webhook_header_name_value import WebhookHeaderNameValue
from mailslurp_client.models.webhook_headers import WebhookHeaders
from mailslurp_client.models.webhook_new_attachment_payload import WebhookNewAttachmentPayload
from mailslurp_client.models.webhook_new_contact_payload import WebhookNewContactPayload
from mailslurp_client.models.webhook_new_email_payload import WebhookNewEmailPayload
from mailslurp_client.models.webhook_new_sms_payload import WebhookNewSmsPayload
from mailslurp_client.models.webhook_projection import WebhookProjection
from mailslurp_client.models.webhook_redrive_all_result import WebhookRedriveAllResult
from mailslurp_client.models.webhook_redrive_result import WebhookRedriveResult
from mailslurp_client.models.webhook_result_dto import WebhookResultDto
from mailslurp_client.models.webhook_test_request import WebhookTestRequest
from mailslurp_client.models.webhook_test_response import WebhookTestResponse
from mailslurp_client.models.webhook_test_result import WebhookTestResult

mailslurp_client/models/webhook_test_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookTestResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'message': 'str',
        'response': 'WebhookTestResponse',
        'request': 'WebhookTestRequest'
    }

    attribute_map = {
        'message': 'message',
        'response': 'response',
        'request': 'request'
    }

    def __init__(self, message=None, response=None, request=None, local_vars_configuration=None):  # noqa: E501
        """WebhookTestResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._message = None
        self._response = None
        self._request = None
        self.discriminator = None

        self.message = message
        self.response = response
        self.request = request

    @property
    def message(self):
        """Gets the message of this WebhookTestResult.  # noqa: E501


        :return: The message of this WebhookTestResult.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this WebhookTestResult.


        :param message: The message of this WebhookTestResult.  # noqa: E501
        :type: str
        """

        self._message = message

    @property
    def response(self):
        """Gets the response of this WebhookTestResult.  # noqa: E501


        :return: The response of this WebhookTestResult.  # noqa: E501
        :rtype: WebhookTestResponse
        """
        return self._response

    @response.setter
    def response(self, response):
        """Sets the response of this WebhookTestResult.


        :param response: The response of this WebhookTestResult.  # noqa: E501
        :type: WebhookTestResponse
        """
        if self.local_vars_configuration.client_side_validation and response is None:  # noqa: E501
            raise ValueError("Invalid value for `response`, must not be `None`")  # noqa: E501

        self._response = response

    @property
    def request(self):
        """Gets the request of this WebhookTestResult.  # noqa: E501


        :return: The request of this WebhookTestResult.  # noqa: E501
        :rtype: WebhookTestRequest
        """
        return self._request

    @request.setter
    def request(self, request):
        """Sets the request of this WebhookTestResult.


        :param request: The request of this WebhookTestResult.  # noqa: E501
        :type: WebhookTestRequest
        """
        if self.local_vars_configuration.client_side_validation and request is None:  # noqa: E501
            raise ValueError("Invalid value for `request`, must not be `None`")  # noqa: E501

        self._request = request

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookTestResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookTestResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_test_response.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookTestResponse(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'status_code': 'int',
        'message': 'str'
    }

    attribute_map = {
        'status_code': 'statusCode',
        'message': 'message'
    }

    def __init__(self, status_code=None, message=None, local_vars_configuration=None):  # noqa: E501
        """WebhookTestResponse - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._status_code = None
        self._message = None
        self.discriminator = None

        self.status_code = status_code
        self.message = message

    @property
    def status_code(self):
        """Gets the status_code of this WebhookTestResponse.  # noqa: E501


        :return: The status_code of this WebhookTestResponse.  # noqa: E501
        :rtype: int
        """
        return self._status_code

    @status_code.setter
    def status_code(self, status_code):
        """Sets the status_code of this WebhookTestResponse.


        :param status_code: The status_code of this WebhookTestResponse.  # noqa: E501
        :type: int
        """

        self._status_code = status_code

    @property
    def message(self):
        """Gets the message of this WebhookTestResponse.  # noqa: E501


        :return: The message of this WebhookTestResponse.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this WebhookTestResponse.


        :param message: The message of this WebhookTestResponse.  # noqa: E501
        :type: str
        """

        self._message = message

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookTestResponse):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookTestResponse):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_test_request.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookTestRequest(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'url': 'str',
        'method': 'str',
        'headers': 'dict(str, str)',
        'payload': 'str'
    }

    attribute_map = {
        'url': 'url',
        'method': 'method',
        'headers': 'headers',
        'payload': 'payload'
    }

    def __init__(self, url=None, method=None, headers=None, payload=None, local_vars_configuration=None):  # noqa: E501
        """WebhookTestRequest - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._url = None
        self._method = None
        self._headers = None
        self._payload = None
        self.discriminator = None

        self.url = url
        self.method = method
        self.headers = headers
        self.payload = payload

    @property
    def url(self):
        """Gets the url of this WebhookTestRequest.  # noqa: E501


        :return: The url of this WebhookTestRequest.  # noqa: E501
        :rtype: str
        """
        return self._url

    @url.setter
    def url(self, url):
        """Sets the url of this WebhookTestRequest.


        :param url: The url of this WebhookTestRequest.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and url is None:  # noqa: E501
            raise ValueError("Invalid value for `url`, must not be `None`")  # noqa: E501

        self._url = url

    @property
    def method(self):
        """Gets the method of this WebhookTestRequest.  # noqa: E501


        :return: The method of this WebhookTestRequest.  # noqa: E501
        :rtype: str
        """
        return self._method

    @method.setter
    def method(self, method):
        """Sets the method of this WebhookTestRequest.


        :param method: The method of this WebhookTestRequest.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and method is None:  # noqa: E501
            raise ValueError("Invalid value for `method`, must not be `None`")  # noqa: E501
        allowed_values = ["POST", "DELETE", "GET", "PUT", "PATCH", "HEAD", "OPTIONS", "TRACE"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and method not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `method` ({0}), must be one of {1}"  # noqa: E501
                .format(method, allowed_values)
            )

        self._method = method

    @property
    def headers(self):
        """Gets the headers of this WebhookTestRequest.  # noqa: E501


        :return: The headers of this WebhookTestRequest.  # noqa: E501
        :rtype: dict(str, str)
        """
        return self._headers

    @headers.setter
    def headers(self, headers):
        """Sets the headers of this WebhookTestRequest.


        :param headers: The headers of this WebhookTestRequest.  # noqa: E501
        :type: dict(str, str)
        """
        if self.local_vars_configuration.client_side_validation and headers is None:  # noqa: E501
            raise ValueError("Invalid value for `headers`, must not be `None`")  # noqa: E501

        self._headers = headers

    @property
    def payload(self):
        """Gets the payload of this WebhookTestRequest.  # noqa: E501


        :return: The payload of this WebhookTestRequest.  # noqa: E501
        :rtype: str
        """
        return self._payload

    @payload.setter
    def payload(self, payload):
        """Sets the payload of this WebhookTestRequest.


        :param payload: The payload of this WebhookTestRequest.  # noqa: E501
        :type: str
        """

        self._payload = payload

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookTestRequest):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookTestRequest):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_result_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookResultDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'webhook_id': 'str',
        'webhook_url': 'str',
        'message_id': 'str',
        'redrive_id': 'str',
        'http_method': 'str',
        'webhook_event': 'str',
        'response_status': 'int',
        'response_time_millis': 'int',
        'response_body_extract': 'str',
        'result_type': 'str',
        'created_at': 'datetime',
        'updated_at': 'datetime',
        'seen': 'bool',
        'inbox_id': 'str',
        'email_id': 'str',
        'attachment_id': 'str',
        'phone_id': 'str',
        'sms_id': 'str'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'webhook_id': 'webhookId',
        'webhook_url': 'webhookUrl',
        'message_id': 'messageId',
        'redrive_id': 'redriveId',
        'http_method': 'httpMethod',
        'webhook_event': 'webhookEvent',
        'response_status': 'responseStatus',
        'response_time_millis': 'responseTimeMillis',
        'response_body_extract': 'responseBodyExtract',
        'result_type': 'resultType',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt',
        'seen': 'seen',
        'inbox_id': 'inboxId',
        'email_id': 'emailId',
        'attachment_id': 'attachmentId',
        'phone_id': 'phoneId',
        'sms_id': 'smsId'
    }

    def __init__(self, id=None, user_id=None, webhook_id=None, webhook_url=None, message_id=None, redrive_id=None, http_method=None, webhook_event=None, response_status=None, response_time_millis=None, response_body_extract=None, result_type=None, created_at=None, updated_at=None, seen=None, inbox_id=None, email_id=None, attachment_id=None, phone_id=None, sms_id=None, local_vars_configuration=None):  # noqa: E501
        """WebhookResultDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._webhook_id = None
        self._webhook_url = None
        self._message_id = None
        self._redrive_id = None
        self._http_method = None
        self._webhook_event = None
        self._response_status = None
        self._response_time_millis = None
        self._response_body_extract = None
        self._result_type = None
        self._created_at = None
        self._updated_at = None
        self._seen = None
        self._inbox_id = None
        self._email_id = None
        self._attachment_id = None
        self._phone_id = None
        self._sms_id = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        self.webhook_id = webhook_id
        self.webhook_url = webhook_url
        self.message_id = message_id
        self.redrive_id = redrive_id
        self.http_method = http_method
        self.webhook_event = webhook_event
        self.response_status = response_status
        self.response_time_millis = response_time_millis
        self.response_body_extract = response_body_extract
        self.result_type = result_type
        self.created_at = created_at
        self.updated_at = updated_at
        self.seen = seen
        self.inbox_id = inbox_id
        self.email_id = email_id
        self.attachment_id = attachment_id
        self.phone_id = phone_id
        self.sms_id = sms_id

    @property
    def id(self):
        """Gets the id of this WebhookResultDto.  # noqa: E501


        :return: The id of this WebhookResultDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this WebhookResultDto.


        :param id: The id of this WebhookResultDto.  # noqa: E501
        :type: str
        """

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this WebhookResultDto.  # noqa: E501


        :return: The user_id of this WebhookResultDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this WebhookResultDto.


        :param user_id: The user_id of this WebhookResultDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def webhook_id(self):
        """Gets the webhook_id of this WebhookResultDto.  # noqa: E501


        :return: The webhook_id of this WebhookResultDto.  # noqa: E501
        :rtype: str
        """
        return self._webhook_id

    @webhook_id.setter
    def webhook_id(self, webhook_id):
        """Sets the webhook_id of this WebhookResultDto.


        :param webhook_id: The webhook_id of this WebhookResultDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and webhook_id is None:  # noqa: E501
            raise ValueError("Invalid value for `webhook_id`, must not be `None`")  # noqa: E501

        self._webhook_id = webhook_id

    @property
    def webhook_url(self):
        """Gets the webhook_url of this WebhookResultDto.  # noqa: E501


        :return: The webhook_url of this WebhookResultDto.  # noqa: E501
        :rtype: str
        """
        return self._webhook_url

    @webhook_url.setter
    def webhook_url(self, webhook_url):
        """Sets the webhook_url of this WebhookResultDto.


        :param webhook_url: The webhook_url of this WebhookResultDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and webhook_url is None:  # noqa: E501
            raise ValueError("Invalid value for `webhook_url`, must not be `None`")  # noqa: E501

        self._webhook_url = webhook_url

    @property
    def message_id(self):
        """Gets the message_id of this WebhookResultDto.  # noqa: E501


        :return: The message_id of this WebhookResultDto.  # noqa: E501
        :rtype: str
        """
        return self._message_id

    @message_id.setter
    def message_id(self, message_id):
        """Sets the message_id of this WebhookResultDto.


        :param message_id: The message_id of this WebhookResultDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and message_id is None:  # noqa: E501
            raise ValueError("Invalid value for `message_id`, must not be `None`")  # noqa: E501

        self._message_id = message_id

    @property
    def redrive_id(self):
        """Gets the redrive_id of this WebhookResultDto.  # noqa: E501


        :return: The redrive_id of this WebhookResultDto.  # noqa: E501
        :rtype: str
        """
        return self._redrive_id

    @redrive_id.setter
    def redrive_id(self, redrive_id):
        """Sets the redrive_id of this WebhookResultDto.


        :param redrive_id: The redrive_id of this WebhookResultDto.  # noqa: E501
        :type: str
        """

        self._redrive_id = redrive_id

    @property
    def http_method(self):
        """Gets the http_method of this WebhookResultDto.  # noqa: E501


        :return: The http_method of this WebhookResultDto.  # noqa: E501
        :rtype: str
        """
        return self._http_method

    @http_method.setter
    def http_method(self, http_method):
        """Sets the http_method of this WebhookResultDto.


        :param http_method: The http_method of this WebhookResultDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and http_method is None:  # noqa: E501
            raise ValueError("Invalid value for `http_method`, must not be `None`")  # noqa: E501
        allowed_values = ["POST", "DELETE", "GET", "PUT", "PATCH", "HEAD", "OPTIONS", "TRACE"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and http_method not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `http_method` ({0}), must be one of {1}"  # noqa: E501
                .format(http_method, allowed_values)
            )

        self._http_method = http_method

    @property
    def webhook_event(self):
        """Gets the webhook_event of this WebhookResultDto.  # noqa: E501


        :return: The webhook_event of this WebhookResultDto.  # noqa: E501
        :rtype: str
        """
        return self._webhook_event

    @webhook_event.setter
    def webhook_event(self, webhook_event):
        """Sets the webhook_event of this WebhookResultDto.


        :param webhook_event: The webhook_event of this WebhookResultDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and webhook_event is None:  # noqa: E501
            raise ValueError("Invalid value for `webhook_event`, must not be `None`")  # noqa: E501
        allowed_values = ["EMAIL_RECEIVED", "NEW_EMAIL", "NEW_CONTACT", "NEW_ATTACHMENT", "EMAIL_OPENED", "EMAIL_READ", "DELIVERY_STATUS", "BOUNCE", "BOUNCE_RECIPIENT", "NEW_SMS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and webhook_event not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `webhook_event` ({0}), must be one of {1}"  # noqa: E501
                .format(webhook_event, allowed_values)
            )

        self._webhook_event = webhook_event

    @property
    def response_status(self):
        """Gets the response_status of this WebhookResultDto.  # noqa: E501


        :return: The response_status of this WebhookResultDto.  # noqa: E501
        :rtype: int
        """
        return self._response_status

    @response_status.setter
    def response_status(self, response_status):
        """Sets the response_status of this WebhookResultDto.


        :param response_status: The response_status of this WebhookResultDto.  # noqa: E501
        :type: int
        """

        self._response_status = response_status

    @property
    def response_time_millis(self):
        """Gets the response_time_millis of this WebhookResultDto.  # noqa: E501


        :return: The response_time_millis of this WebhookResultDto.  # noqa: E501
        :rtype: int
        """
        return self._response_time_millis

    @response_time_millis.setter
    def response_time_millis(self, response_time_millis):
        """Sets the response_time_millis of this WebhookResultDto.


        :param response_time_millis: The response_time_millis of this WebhookResultDto.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and response_time_millis is None:  # noqa: E501
            raise ValueError("Invalid value for `response_time_millis`, must not be `None`")  # noqa: E501

        self._response_time_millis = response_time_millis

    @property
    def response_body_extract(self):
        """Gets the response_body_extract of this WebhookResultDto.  # noqa: E501


        :return: The response_body_extract of this WebhookResultDto.  # noqa: E501
        :rtype: str
        """
        return self._response_body_extract

    @response_body_extract.setter
    def response_body_extract(self, response_body_extract):
        """Sets the response_body_extract of this WebhookResultDto.


        :param response_body_extract: The response_body_extract of this WebhookResultDto.  # noqa: E501
        :type: str
        """

        self._response_body_extract = response_body_extract

    @property
    def result_type(self):
        """Gets the result_type of this WebhookResultDto.  # noqa: E501


        :return: The result_type of this WebhookResultDto.  # noqa: E501
        :rtype: str
        """
        return self._result_type

    @result_type.setter
    def result_type(self, result_type):
        """Sets the result_type of this WebhookResultDto.


        :param result_type: The result_type of this WebhookResultDto.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"BAD_RESPONSE", "EXCEPTION", "SUCCESS", "REDRIVEN"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and result_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `result_type` ({0}), must be one of {1}"  # noqa: E501
                .format(result_type, allowed_values)
            )

        self._result_type = result_type

    @property
    def created_at(self):
        """Gets the created_at of this WebhookResultDto.  # noqa: E501


        :return: The created_at of this WebhookResultDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this WebhookResultDto.


        :param created_at: The created_at of this WebhookResultDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this WebhookResultDto.  # noqa: E501


        :return: The updated_at of this WebhookResultDto.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this WebhookResultDto.


        :param updated_at: The updated_at of this WebhookResultDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    @property
    def seen(self):
        """Gets the seen of this WebhookResultDto.  # noqa: E501


        :return: The seen of this WebhookResultDto.  # noqa: E501
        :rtype: bool
        """
        return self._seen

    @seen.setter
    def seen(self, seen):
        """Sets the seen of this WebhookResultDto.


        :param seen: The seen of this WebhookResultDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and seen is None:  # noqa: E501
            raise ValueError("Invalid value for `seen`, must not be `None`")  # noqa: E501

        self._seen = seen

    @property
    def inbox_id(self):
        """Gets the inbox_id of this WebhookResultDto.  # noqa: E501


        :return: The inbox_id of this WebhookResultDto.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this WebhookResultDto.


        :param inbox_id: The inbox_id of this WebhookResultDto.  # noqa: E501
        :type: str
        """

        self._inbox_id = inbox_id

    @property
    def email_id(self):
        """Gets the email_id of this WebhookResultDto.  # noqa: E501


        :return: The email_id of this WebhookResultDto.  # noqa: E501
        :rtype: str
        """
        return self._email_id

    @email_id.setter
    def email_id(self, email_id):
        """Sets the email_id of this WebhookResultDto.


        :param email_id: The email_id of this WebhookResultDto.  # noqa: E501
        :type: str
        """

        self._email_id = email_id

    @property
    def attachment_id(self):
        """Gets the attachment_id of this WebhookResultDto.  # noqa: E501


        :return: The attachment_id of this WebhookResultDto.  # noqa: E501
        :rtype: str
        """
        return self._attachment_id

    @attachment_id.setter
    def attachment_id(self, attachment_id):
        """Sets the attachment_id of this WebhookResultDto.


        :param attachment_id: The attachment_id of this WebhookResultDto.  # noqa: E501
        :type: str
        """

        self._attachment_id = attachment_id

    @property
    def phone_id(self):
        """Gets the phone_id of this WebhookResultDto.  # noqa: E501


        :return: The phone_id of this WebhookResultDto.  # noqa: E501
        :rtype: str
        """
        return self._phone_id

    @phone_id.setter
    def phone_id(self, phone_id):
        """Sets the phone_id of this WebhookResultDto.


        :param phone_id: The phone_id of this WebhookResultDto.  # noqa: E501
        :type: str
        """

        self._phone_id = phone_id

    @property
    def sms_id(self):
        """Gets the sms_id of this WebhookResultDto.  # noqa: E501


        :return: The sms_id of this WebhookResultDto.  # noqa: E501
        :rtype: str
        """
        return self._sms_id

    @sms_id.setter
    def sms_id(self, sms_id):
        """Sets the sms_id of this WebhookResultDto.


        :param sms_id: The sms_id of this WebhookResultDto.  # noqa: E501
        :type: str
        """

        self._sms_id = sms_id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookResultDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookResultDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_redrive_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookRedriveResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'webhook_result_id': 'str',
        'success': 'bool',
        'message': 'str'
    }

    attribute_map = {
        'webhook_result_id': 'webhookResultId',
        'success': 'success',
        'message': 'message'
    }

    def __init__(self, webhook_result_id=None, success=None, message=None, local_vars_configuration=None):  # noqa: E501
        """WebhookRedriveResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._webhook_result_id = None
        self._success = None
        self._message = None
        self.discriminator = None

        self.webhook_result_id = webhook_result_id
        self.success = success
        self.message = message

    @property
    def webhook_result_id(self):
        """Gets the webhook_result_id of this WebhookRedriveResult.  # noqa: E501


        :return: The webhook_result_id of this WebhookRedriveResult.  # noqa: E501
        :rtype: str
        """
        return self._webhook_result_id

    @webhook_result_id.setter
    def webhook_result_id(self, webhook_result_id):
        """Sets the webhook_result_id of this WebhookRedriveResult.


        :param webhook_result_id: The webhook_result_id of this WebhookRedriveResult.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and webhook_result_id is None:  # noqa: E501
            raise ValueError("Invalid value for `webhook_result_id`, must not be `None`")  # noqa: E501

        self._webhook_result_id = webhook_result_id

    @property
    def success(self):
        """Gets the success of this WebhookRedriveResult.  # noqa: E501


        :return: The success of this WebhookRedriveResult.  # noqa: E501
        :rtype: bool
        """
        return self._success

    @success.setter
    def success(self, success):
        """Sets the success of this WebhookRedriveResult.


        :param success: The success of this WebhookRedriveResult.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and success is None:  # noqa: E501
            raise ValueError("Invalid value for `success`, must not be `None`")  # noqa: E501

        self._success = success

    @property
    def message(self):
        """Gets the message of this WebhookRedriveResult.  # noqa: E501


        :return: The message of this WebhookRedriveResult.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this WebhookRedriveResult.


        :param message: The message of this WebhookRedriveResult.  # noqa: E501
        :type: str
        """

        self._message = message

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookRedriveResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookRedriveResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_redrive_all_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookRedriveAllResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'success': 'bool',
        'message': 'str'
    }

    attribute_map = {
        'success': 'success',
        'message': 'message'
    }

    def __init__(self, success=None, message=None, local_vars_configuration=None):  # noqa: E501
        """WebhookRedriveAllResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._success = None
        self._message = None
        self.discriminator = None

        self.success = success
        self.message = message

    @property
    def success(self):
        """Gets the success of this WebhookRedriveAllResult.  # noqa: E501


        :return: The success of this WebhookRedriveAllResult.  # noqa: E501
        :rtype: bool
        """
        return self._success

    @success.setter
    def success(self, success):
        """Sets the success of this WebhookRedriveAllResult.


        :param success: The success of this WebhookRedriveAllResult.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and success is None:  # noqa: E501
            raise ValueError("Invalid value for `success`, must not be `None`")  # noqa: E501

        self._success = success

    @property
    def message(self):
        """Gets the message of this WebhookRedriveAllResult.  # noqa: E501


        :return: The message of this WebhookRedriveAllResult.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this WebhookRedriveAllResult.


        :param message: The message of this WebhookRedriveAllResult.  # noqa: E501
        :type: str
        """

        self._message = message

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookRedriveAllResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookRedriveAllResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'updated_at': 'datetime',
        'url': 'str',
        'inbox_id': 'str',
        'event_name': 'str',
        'phone_number_id': 'str',
        'name': 'str',
        'id': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'updated_at': 'updatedAt',
        'url': 'url',
        'inbox_id': 'inboxId',
        'event_name': 'eventName',
        'phone_number_id': 'phoneNumberId',
        'name': 'name',
        'id': 'id'
    }

    def __init__(self, created_at=None, updated_at=None, url=None, inbox_id=None, event_name=None, phone_number_id=None, name=None, id=None, local_vars_configuration=None):  # noqa: E501
        """WebhookProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._updated_at = None
        self._url = None
        self._inbox_id = None
        self._event_name = None
        self._phone_number_id = None
        self._name = None
        self._id = None
        self.discriminator = None

        self.created_at = created_at
        self.updated_at = updated_at
        self.url = url
        if inbox_id is not None:
            self.inbox_id = inbox_id
        if event_name is not None:
            self.event_name = event_name
        if phone_number_id is not None:
            self.phone_number_id = phone_number_id
        if name is not None:
            self.name = name
        self.id = id

    @property
    def created_at(self):
        """Gets the created_at of this WebhookProjection.  # noqa: E501


        :return: The created_at of this WebhookProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this WebhookProjection.


        :param created_at: The created_at of this WebhookProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this WebhookProjection.  # noqa: E501


        :return: The updated_at of this WebhookProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this WebhookProjection.


        :param updated_at: The updated_at of this WebhookProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    @property
    def url(self):
        """Gets the url of this WebhookProjection.  # noqa: E501


        :return: The url of this WebhookProjection.  # noqa: E501
        :rtype: str
        """
        return self._url

    @url.setter
    def url(self, url):
        """Sets the url of this WebhookProjection.


        :param url: The url of this WebhookProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and url is None:  # noqa: E501
            raise ValueError("Invalid value for `url`, must not be `None`")  # noqa: E501

        self._url = url

    @property
    def inbox_id(self):
        """Gets the inbox_id of this WebhookProjection.  # noqa: E501


        :return: The inbox_id of this WebhookProjection.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this WebhookProjection.


        :param inbox_id: The inbox_id of this WebhookProjection.  # noqa: E501
        :type: str
        """

        self._inbox_id = inbox_id

    @property
    def event_name(self):
        """Gets the event_name of this WebhookProjection.  # noqa: E501


        :return: The event_name of this WebhookProjection.  # noqa: E501
        :rtype: str
        """
        return self._event_name

    @event_name.setter
    def event_name(self, event_name):
        """Sets the event_name of this WebhookProjection.


        :param event_name: The event_name of this WebhookProjection.  # noqa: E501
        :type: str
        """
        allowed_values = ["EMAIL_RECEIVED", "NEW_EMAIL", "NEW_CONTACT", "NEW_ATTACHMENT", "EMAIL_OPENED", "EMAIL_READ", "DELIVERY_STATUS", "BOUNCE", "BOUNCE_RECIPIENT", "NEW_SMS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and event_name not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `event_name` ({0}), must be one of {1}"  # noqa: E501
                .format(event_name, allowed_values)
            )

        self._event_name = event_name

    @property
    def phone_number_id(self):
        """Gets the phone_number_id of this WebhookProjection.  # noqa: E501


        :return: The phone_number_id of this WebhookProjection.  # noqa: E501
        :rtype: str
        """
        return self._phone_number_id

    @phone_number_id.setter
    def phone_number_id(self, phone_number_id):
        """Sets the phone_number_id of this WebhookProjection.


        :param phone_number_id: The phone_number_id of this WebhookProjection.  # noqa: E501
        :type: str
        """

        self._phone_number_id = phone_number_id

    @property
    def name(self):
        """Gets the name of this WebhookProjection.  # noqa: E501


        :return: The name of this WebhookProjection.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this WebhookProjection.


        :param name: The name of this WebhookProjection.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def id(self):
        """Gets the id of this WebhookProjection.  # noqa: E501


        :return: The id of this WebhookProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this WebhookProjection.


        :param id: The id of this WebhookProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_new_sms_payload.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookNewSmsPayload(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'message_id': 'str',
        'webhook_id': 'str',
        'event_name': 'str',
        'webhook_name': 'str',
        'sms_id': 'str',
        'user_id': 'str',
        'phone_number': 'str',
        'to_number': 'str',
        'from_number': 'str',
        'body': 'str',
        'read': 'bool'
    }

    attribute_map = {
        'message_id': 'messageId',
        'webhook_id': 'webhookId',
        'event_name': 'eventName',
        'webhook_name': 'webhookName',
        'sms_id': 'smsId',
        'user_id': 'userId',
        'phone_number': 'phoneNumber',
        'to_number': 'toNumber',
        'from_number': 'fromNumber',
        'body': 'body',
        'read': 'read'
    }

    def __init__(self, message_id=None, webhook_id=None, event_name=None, webhook_name=None, sms_id=None, user_id=None, phone_number=None, to_number=None, from_number=None, body=None, read=None, local_vars_configuration=None):  # noqa: E501
        """WebhookNewSmsPayload - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._message_id = None
        self._webhook_id = None
        self._event_name = None
        self._webhook_name = None
        self._sms_id = None
        self._user_id = None
        self._phone_number = None
        self._to_number = None
        self._from_number = None
        self._body = None
        self._read = None
        self.discriminator = None

        self.message_id = message_id
        self.webhook_id = webhook_id
        self.event_name = event_name
        self.webhook_name = webhook_name
        self.sms_id = sms_id
        self.user_id = user_id
        self.phone_number = phone_number
        self.to_number = to_number
        self.from_number = from_number
        self.body = body
        self.read = read

    @property
    def message_id(self):
        """Gets the message_id of this WebhookNewSmsPayload.  # noqa: E501

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :return: The message_id of this WebhookNewSmsPayload.  # noqa: E501
        :rtype: str
        """
        return self._message_id

    @message_id.setter
    def message_id(self, message_id):
        """Sets the message_id of this WebhookNewSmsPayload.

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :param message_id: The message_id of this WebhookNewSmsPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and message_id is None:  # noqa: E501
            raise ValueError("Invalid value for `message_id`, must not be `None`")  # noqa: E501

        self._message_id = message_id

    @property
    def webhook_id(self):
        """Gets the webhook_id of this WebhookNewSmsPayload.  # noqa: E501

        ID of webhook entity being triggered  # noqa: E501

        :return: The webhook_id of this WebhookNewSmsPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_id

    @webhook_id.setter
    def webhook_id(self, webhook_id):
        """Sets the webhook_id of this WebhookNewSmsPayload.

        ID of webhook entity being triggered  # noqa: E501

        :param webhook_id: The webhook_id of this WebhookNewSmsPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and webhook_id is None:  # noqa: E501
            raise ValueError("Invalid value for `webhook_id`, must not be `None`")  # noqa: E501

        self._webhook_id = webhook_id

    @property
    def event_name(self):
        """Gets the event_name of this WebhookNewSmsPayload.  # noqa: E501

        Name of the event type webhook is being triggered for.  # noqa: E501

        :return: The event_name of this WebhookNewSmsPayload.  # noqa: E501
        :rtype: str
        """
        return self._event_name

    @event_name.setter
    def event_name(self, event_name):
        """Sets the event_name of this WebhookNewSmsPayload.

        Name of the event type webhook is being triggered for.  # noqa: E501

        :param event_name: The event_name of this WebhookNewSmsPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and event_name is None:  # noqa: E501
            raise ValueError("Invalid value for `event_name`, must not be `None`")  # noqa: E501
        allowed_values = ["EMAIL_RECEIVED", "NEW_EMAIL", "NEW_CONTACT", "NEW_ATTACHMENT", "EMAIL_OPENED", "EMAIL_READ", "DELIVERY_STATUS", "BOUNCE", "BOUNCE_RECIPIENT", "NEW_SMS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and event_name not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `event_name` ({0}), must be one of {1}"  # noqa: E501
                .format(event_name, allowed_values)
            )

        self._event_name = event_name

    @property
    def webhook_name(self):
        """Gets the webhook_name of this WebhookNewSmsPayload.  # noqa: E501

        Name of the webhook being triggered  # noqa: E501

        :return: The webhook_name of this WebhookNewSmsPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_name

    @webhook_name.setter
    def webhook_name(self, webhook_name):
        """Sets the webhook_name of this WebhookNewSmsPayload.

        Name of the webhook being triggered  # noqa: E501

        :param webhook_name: The webhook_name of this WebhookNewSmsPayload.  # noqa: E501
        :type: str
        """

        self._webhook_name = webhook_name

    @property
    def sms_id(self):
        """Gets the sms_id of this WebhookNewSmsPayload.  # noqa: E501

        ID of SMS message  # noqa: E501

        :return: The sms_id of this WebhookNewSmsPayload.  # noqa: E501
        :rtype: str
        """
        return self._sms_id

    @sms_id.setter
    def sms_id(self, sms_id):
        """Sets the sms_id of this WebhookNewSmsPayload.

        ID of SMS message  # noqa: E501

        :param sms_id: The sms_id of this WebhookNewSmsPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and sms_id is None:  # noqa: E501
            raise ValueError("Invalid value for `sms_id`, must not be `None`")  # noqa: E501

        self._sms_id = sms_id

    @property
    def user_id(self):
        """Gets the user_id of this WebhookNewSmsPayload.  # noqa: E501

        User ID of event  # noqa: E501

        :return: The user_id of this WebhookNewSmsPayload.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this WebhookNewSmsPayload.

        User ID of event  # noqa: E501

        :param user_id: The user_id of this WebhookNewSmsPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def phone_number(self):
        """Gets the phone_number of this WebhookNewSmsPayload.  # noqa: E501

        ID of phone number receiving SMS  # noqa: E501

        :return: The phone_number of this WebhookNewSmsPayload.  # noqa: E501
        :rtype: str
        """
        return self._phone_number

    @phone_number.setter
    def phone_number(self, phone_number):
        """Sets the phone_number of this WebhookNewSmsPayload.

        ID of phone number receiving SMS  # noqa: E501

        :param phone_number: The phone_number of this WebhookNewSmsPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and phone_number is None:  # noqa: E501
            raise ValueError("Invalid value for `phone_number`, must not be `None`")  # noqa: E501

        self._phone_number = phone_number

    @property
    def to_number(self):
        """Gets the to_number of this WebhookNewSmsPayload.  # noqa: E501

        Recipient phone number  # noqa: E501

        :return: The to_number of this WebhookNewSmsPayload.  # noqa: E501
        :rtype: str
        """
        return self._to_number

    @to_number.setter
    def to_number(self, to_number):
        """Sets the to_number of this WebhookNewSmsPayload.

        Recipient phone number  # noqa: E501

        :param to_number: The to_number of this WebhookNewSmsPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and to_number is None:  # noqa: E501
            raise ValueError("Invalid value for `to_number`, must not be `None`")  # noqa: E501

        self._to_number = to_number

    @property
    def from_number(self):
        """Gets the from_number of this WebhookNewSmsPayload.  # noqa: E501

        Sender phone number  # noqa: E501

        :return: The from_number of this WebhookNewSmsPayload.  # noqa: E501
        :rtype: str
        """
        return self._from_number

    @from_number.setter
    def from_number(self, from_number):
        """Sets the from_number of this WebhookNewSmsPayload.

        Sender phone number  # noqa: E501

        :param from_number: The from_number of this WebhookNewSmsPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and from_number is None:  # noqa: E501
            raise ValueError("Invalid value for `from_number`, must not be `None`")  # noqa: E501

        self._from_number = from_number

    @property
    def body(self):
        """Gets the body of this WebhookNewSmsPayload.  # noqa: E501

        SMS message body  # noqa: E501

        :return: The body of this WebhookNewSmsPayload.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this WebhookNewSmsPayload.

        SMS message body  # noqa: E501

        :param body: The body of this WebhookNewSmsPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and body is None:  # noqa: E501
            raise ValueError("Invalid value for `body`, must not be `None`")  # noqa: E501

        self._body = body

    @property
    def read(self):
        """Gets the read of this WebhookNewSmsPayload.  # noqa: E501

        SMS has been read  # noqa: E501

        :return: The read of this WebhookNewSmsPayload.  # noqa: E501
        :rtype: bool
        """
        return self._read

    @read.setter
    def read(self, read):
        """Sets the read of this WebhookNewSmsPayload.

        SMS has been read  # noqa: E501

        :param read: The read of this WebhookNewSmsPayload.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and read is None:  # noqa: E501
            raise ValueError("Invalid value for `read`, must not be `None`")  # noqa: E501

        self._read = read

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookNewSmsPayload):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookNewSmsPayload):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_new_email_payload.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookNewEmailPayload(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'message_id': 'str',
        'webhook_id': 'str',
        'event_name': 'str',
        'webhook_name': 'str',
        'inbox_id': 'str',
        'domain_id': 'str',
        'email_id': 'str',
        'created_at': 'datetime',
        'to': 'list[str]',
        '_from': 'str',
        'cc': 'list[str]',
        'bcc': 'list[str]',
        'subject': 'str',
        'attachment_meta_datas': 'list[AttachmentMetaData]'
    }

    attribute_map = {
        'message_id': 'messageId',
        'webhook_id': 'webhookId',
        'event_name': 'eventName',
        'webhook_name': 'webhookName',
        'inbox_id': 'inboxId',
        'domain_id': 'domainId',
        'email_id': 'emailId',
        'created_at': 'createdAt',
        'to': 'to',
        '_from': 'from',
        'cc': 'cc',
        'bcc': 'bcc',
        'subject': 'subject',
        'attachment_meta_datas': 'attachmentMetaDatas'
    }

    def __init__(self, message_id=None, webhook_id=None, event_name=None, webhook_name=None, inbox_id=None, domain_id=None, email_id=None, created_at=None, to=None, _from=None, cc=None, bcc=None, subject=None, attachment_meta_datas=None, local_vars_configuration=None):  # noqa: E501
        """WebhookNewEmailPayload - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._message_id = None
        self._webhook_id = None
        self._event_name = None
        self._webhook_name = None
        self._inbox_id = None
        self._domain_id = None
        self._email_id = None
        self._created_at = None
        self._to = None
        self.__from = None
        self._cc = None
        self._bcc = None
        self._subject = None
        self._attachment_meta_datas = None
        self.discriminator = None

        self.message_id = message_id
        self.webhook_id = webhook_id
        self.event_name = event_name
        self.webhook_name = webhook_name
        self.inbox_id = inbox_id
        self.domain_id = domain_id
        self.email_id = email_id
        self.created_at = created_at
        self.to = to
        self._from = _from
        self.cc = cc
        self.bcc = bcc
        self.subject = subject
        self.attachment_meta_datas = attachment_meta_datas

    @property
    def message_id(self):
        """Gets the message_id of this WebhookNewEmailPayload.  # noqa: E501

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :return: The message_id of this WebhookNewEmailPayload.  # noqa: E501
        :rtype: str
        """
        return self._message_id

    @message_id.setter
    def message_id(self, message_id):
        """Sets the message_id of this WebhookNewEmailPayload.

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :param message_id: The message_id of this WebhookNewEmailPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and message_id is None:  # noqa: E501
            raise ValueError("Invalid value for `message_id`, must not be `None`")  # noqa: E501

        self._message_id = message_id

    @property
    def webhook_id(self):
        """Gets the webhook_id of this WebhookNewEmailPayload.  # noqa: E501

        ID of webhook entity being triggered  # noqa: E501

        :return: The webhook_id of this WebhookNewEmailPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_id

    @webhook_id.setter
    def webhook_id(self, webhook_id):
        """Sets the webhook_id of this WebhookNewEmailPayload.

        ID of webhook entity being triggered  # noqa: E501

        :param webhook_id: The webhook_id of this WebhookNewEmailPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and webhook_id is None:  # noqa: E501
            raise ValueError("Invalid value for `webhook_id`, must not be `None`")  # noqa: E501

        self._webhook_id = webhook_id

    @property
    def event_name(self):
        """Gets the event_name of this WebhookNewEmailPayload.  # noqa: E501

        Name of the event type webhook is being triggered for.  # noqa: E501

        :return: The event_name of this WebhookNewEmailPayload.  # noqa: E501
        :rtype: str
        """
        return self._event_name

    @event_name.setter
    def event_name(self, event_name):
        """Sets the event_name of this WebhookNewEmailPayload.

        Name of the event type webhook is being triggered for.  # noqa: E501

        :param event_name: The event_name of this WebhookNewEmailPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and event_name is None:  # noqa: E501
            raise ValueError("Invalid value for `event_name`, must not be `None`")  # noqa: E501
        allowed_values = ["EMAIL_RECEIVED", "NEW_EMAIL", "NEW_CONTACT", "NEW_ATTACHMENT", "EMAIL_OPENED", "EMAIL_READ", "DELIVERY_STATUS", "BOUNCE", "BOUNCE_RECIPIENT", "NEW_SMS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and event_name not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `event_name` ({0}), must be one of {1}"  # noqa: E501
                .format(event_name, allowed_values)
            )

        self._event_name = event_name

    @property
    def webhook_name(self):
        """Gets the webhook_name of this WebhookNewEmailPayload.  # noqa: E501

        Name of the webhook being triggered  # noqa: E501

        :return: The webhook_name of this WebhookNewEmailPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_name

    @webhook_name.setter
    def webhook_name(self, webhook_name):
        """Sets the webhook_name of this WebhookNewEmailPayload.

        Name of the webhook being triggered  # noqa: E501

        :param webhook_name: The webhook_name of this WebhookNewEmailPayload.  # noqa: E501
        :type: str
        """

        self._webhook_name = webhook_name

    @property
    def inbox_id(self):
        """Gets the inbox_id of this WebhookNewEmailPayload.  # noqa: E501

        Id of the inbox  # noqa: E501

        :return: The inbox_id of this WebhookNewEmailPayload.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this WebhookNewEmailPayload.

        Id of the inbox  # noqa: E501

        :param inbox_id: The inbox_id of this WebhookNewEmailPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def domain_id(self):
        """Gets the domain_id of this WebhookNewEmailPayload.  # noqa: E501

        Id of the domain that received an email  # noqa: E501

        :return: The domain_id of this WebhookNewEmailPayload.  # noqa: E501
        :rtype: str
        """
        return self._domain_id

    @domain_id.setter
    def domain_id(self, domain_id):
        """Sets the domain_id of this WebhookNewEmailPayload.

        Id of the domain that received an email  # noqa: E501

        :param domain_id: The domain_id of this WebhookNewEmailPayload.  # noqa: E501
        :type: str
        """

        self._domain_id = domain_id

    @property
    def email_id(self):
        """Gets the email_id of this WebhookNewEmailPayload.  # noqa: E501

        ID of the email that was received. Use this ID for fetching the email with the `EmailController`.  # noqa: E501

        :return: The email_id of this WebhookNewEmailPayload.  # noqa: E501
        :rtype: str
        """
        return self._email_id

    @email_id.setter
    def email_id(self, email_id):
        """Sets the email_id of this WebhookNewEmailPayload.

        ID of the email that was received. Use this ID for fetching the email with the `EmailController`.  # noqa: E501

        :param email_id: The email_id of this WebhookNewEmailPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_id is None:  # noqa: E501
            raise ValueError("Invalid value for `email_id`, must not be `None`")  # noqa: E501

        self._email_id = email_id

    @property
    def created_at(self):
        """Gets the created_at of this WebhookNewEmailPayload.  # noqa: E501

        Date time of event creation  # noqa: E501

        :return: The created_at of this WebhookNewEmailPayload.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this WebhookNewEmailPayload.

        Date time of event creation  # noqa: E501

        :param created_at: The created_at of this WebhookNewEmailPayload.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def to(self):
        """Gets the to of this WebhookNewEmailPayload.  # noqa: E501

        List of `To` recipient email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :return: The to of this WebhookNewEmailPayload.  # noqa: E501
        :rtype: list[str]
        """
        return self._to

    @to.setter
    def to(self, to):
        """Sets the to of this WebhookNewEmailPayload.

        List of `To` recipient email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :param to: The to of this WebhookNewEmailPayload.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and to is None:  # noqa: E501
            raise ValueError("Invalid value for `to`, must not be `None`")  # noqa: E501

        self._to = to

    @property
    def _from(self):
        """Gets the _from of this WebhookNewEmailPayload.  # noqa: E501

        Who the email was sent from. An email address - see fromName for the sender name.  # noqa: E501

        :return: The _from of this WebhookNewEmailPayload.  # noqa: E501
        :rtype: str
        """
        return self.__from

    @_from.setter
    def _from(self, _from):
        """Sets the _from of this WebhookNewEmailPayload.

        Who the email was sent from. An email address - see fromName for the sender name.  # noqa: E501

        :param _from: The _from of this WebhookNewEmailPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and _from is None:  # noqa: E501
            raise ValueError("Invalid value for `_from`, must not be `None`")  # noqa: E501

        self.__from = _from

    @property
    def cc(self):
        """Gets the cc of this WebhookNewEmailPayload.  # noqa: E501

        List of `CC` recipients email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :return: The cc of this WebhookNewEmailPayload.  # noqa: E501
        :rtype: list[str]
        """
        return self._cc

    @cc.setter
    def cc(self, cc):
        """Sets the cc of this WebhookNewEmailPayload.

        List of `CC` recipients email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :param cc: The cc of this WebhookNewEmailPayload.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and cc is None:  # noqa: E501
            raise ValueError("Invalid value for `cc`, must not be `None`")  # noqa: E501

        self._cc = cc

    @property
    def bcc(self):
        """Gets the bcc of this WebhookNewEmailPayload.  # noqa: E501

        List of `BCC` recipients email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :return: The bcc of this WebhookNewEmailPayload.  # noqa: E501
        :rtype: list[str]
        """
        return self._bcc

    @bcc.setter
    def bcc(self, bcc):
        """Sets the bcc of this WebhookNewEmailPayload.

        List of `BCC` recipients email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :param bcc: The bcc of this WebhookNewEmailPayload.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and bcc is None:  # noqa: E501
            raise ValueError("Invalid value for `bcc`, must not be `None`")  # noqa: E501

        self._bcc = bcc

    @property
    def subject(self):
        """Gets the subject of this WebhookNewEmailPayload.  # noqa: E501

        The subject line of the email message as specified by SMTP subject header  # noqa: E501

        :return: The subject of this WebhookNewEmailPayload.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this WebhookNewEmailPayload.

        The subject line of the email message as specified by SMTP subject header  # noqa: E501

        :param subject: The subject of this WebhookNewEmailPayload.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def attachment_meta_datas(self):
        """Gets the attachment_meta_datas of this WebhookNewEmailPayload.  # noqa: E501

        List of attachment meta data objects if attachments present  # noqa: E501

        :return: The attachment_meta_datas of this WebhookNewEmailPayload.  # noqa: E501
        :rtype: list[AttachmentMetaData]
        """
        return self._attachment_meta_datas

    @attachment_meta_datas.setter
    def attachment_meta_datas(self, attachment_meta_datas):
        """Sets the attachment_meta_datas of this WebhookNewEmailPayload.

        List of attachment meta data objects if attachments present  # noqa: E501

        :param attachment_meta_datas: The attachment_meta_datas of this WebhookNewEmailPayload.  # noqa: E501
        :type: list[AttachmentMetaData]
        """
        if self.local_vars_configuration.client_side_validation and attachment_meta_datas is None:  # noqa: E501
            raise ValueError("Invalid value for `attachment_meta_datas`, must not be `None`")  # noqa: E501

        self._attachment_meta_datas = attachment_meta_datas

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookNewEmailPayload):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookNewEmailPayload):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_new_contact_payload.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookNewContactPayload(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'message_id': 'str',
        'webhook_id': 'str',
        'webhook_name': 'str',
        'event_name': 'str',
        'contact_id': 'str',
        'group_id': 'str',
        'first_name': 'str',
        'last_name': 'str',
        'company': 'str',
        'primary_email_address': 'str',
        'email_addresses': 'list[str]',
        'tags': 'list[str]',
        'meta_data': 'object',
        'opt_out': 'bool',
        'created_at': 'datetime'
    }

    attribute_map = {
        'message_id': 'messageId',
        'webhook_id': 'webhookId',
        'webhook_name': 'webhookName',
        'event_name': 'eventName',
        'contact_id': 'contactId',
        'group_id': 'groupId',
        'first_name': 'firstName',
        'last_name': 'lastName',
        'company': 'company',
        'primary_email_address': 'primaryEmailAddress',
        'email_addresses': 'emailAddresses',
        'tags': 'tags',
        'meta_data': 'metaData',
        'opt_out': 'optOut',
        'created_at': 'createdAt'
    }

    def __init__(self, message_id=None, webhook_id=None, webhook_name=None, event_name=None, contact_id=None, group_id=None, first_name=None, last_name=None, company=None, primary_email_address=None, email_addresses=None, tags=None, meta_data=None, opt_out=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """WebhookNewContactPayload - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._message_id = None
        self._webhook_id = None
        self._webhook_name = None
        self._event_name = None
        self._contact_id = None
        self._group_id = None
        self._first_name = None
        self._last_name = None
        self._company = None
        self._primary_email_address = None
        self._email_addresses = None
        self._tags = None
        self._meta_data = None
        self._opt_out = None
        self._created_at = None
        self.discriminator = None

        self.message_id = message_id
        self.webhook_id = webhook_id
        self.webhook_name = webhook_name
        self.event_name = event_name
        self.contact_id = contact_id
        self.group_id = group_id
        self.first_name = first_name
        self.last_name = last_name
        self.company = company
        self.primary_email_address = primary_email_address
        self.email_addresses = email_addresses
        self.tags = tags
        self.meta_data = meta_data
        self.opt_out = opt_out
        self.created_at = created_at

    @property
    def message_id(self):
        """Gets the message_id of this WebhookNewContactPayload.  # noqa: E501

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :return: The message_id of this WebhookNewContactPayload.  # noqa: E501
        :rtype: str
        """
        return self._message_id

    @message_id.setter
    def message_id(self, message_id):
        """Sets the message_id of this WebhookNewContactPayload.

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :param message_id: The message_id of this WebhookNewContactPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and message_id is None:  # noqa: E501
            raise ValueError("Invalid value for `message_id`, must not be `None`")  # noqa: E501

        self._message_id = message_id

    @property
    def webhook_id(self):
        """Gets the webhook_id of this WebhookNewContactPayload.  # noqa: E501

        ID of webhook entity being triggered  # noqa: E501

        :return: The webhook_id of this WebhookNewContactPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_id

    @webhook_id.setter
    def webhook_id(self, webhook_id):
        """Sets the webhook_id of this WebhookNewContactPayload.

        ID of webhook entity being triggered  # noqa: E501

        :param webhook_id: The webhook_id of this WebhookNewContactPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and webhook_id is None:  # noqa: E501
            raise ValueError("Invalid value for `webhook_id`, must not be `None`")  # noqa: E501

        self._webhook_id = webhook_id

    @property
    def webhook_name(self):
        """Gets the webhook_name of this WebhookNewContactPayload.  # noqa: E501

        Name of the webhook being triggered  # noqa: E501

        :return: The webhook_name of this WebhookNewContactPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_name

    @webhook_name.setter
    def webhook_name(self, webhook_name):
        """Sets the webhook_name of this WebhookNewContactPayload.

        Name of the webhook being triggered  # noqa: E501

        :param webhook_name: The webhook_name of this WebhookNewContactPayload.  # noqa: E501
        :type: str
        """

        self._webhook_name = webhook_name

    @property
    def event_name(self):
        """Gets the event_name of this WebhookNewContactPayload.  # noqa: E501

        Name of the event type webhook is being triggered for.  # noqa: E501

        :return: The event_name of this WebhookNewContactPayload.  # noqa: E501
        :rtype: str
        """
        return self._event_name

    @event_name.setter
    def event_name(self, event_name):
        """Sets the event_name of this WebhookNewContactPayload.

        Name of the event type webhook is being triggered for.  # noqa: E501

        :param event_name: The event_name of this WebhookNewContactPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and event_name is None:  # noqa: E501
            raise ValueError("Invalid value for `event_name`, must not be `None`")  # noqa: E501
        allowed_values = ["EMAIL_RECEIVED", "NEW_EMAIL", "NEW_CONTACT", "NEW_ATTACHMENT", "EMAIL_OPENED", "EMAIL_READ", "DELIVERY_STATUS", "BOUNCE", "BOUNCE_RECIPIENT", "NEW_SMS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and event_name not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `event_name` ({0}), must be one of {1}"  # noqa: E501
                .format(event_name, allowed_values)
            )

        self._event_name = event_name

    @property
    def contact_id(self):
        """Gets the contact_id of this WebhookNewContactPayload.  # noqa: E501

        Contact ID  # noqa: E501

        :return: The contact_id of this WebhookNewContactPayload.  # noqa: E501
        :rtype: str
        """
        return self._contact_id

    @contact_id.setter
    def contact_id(self, contact_id):
        """Sets the contact_id of this WebhookNewContactPayload.

        Contact ID  # noqa: E501

        :param contact_id: The contact_id of this WebhookNewContactPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and contact_id is None:  # noqa: E501
            raise ValueError("Invalid value for `contact_id`, must not be `None`")  # noqa: E501

        self._contact_id = contact_id

    @property
    def group_id(self):
        """Gets the group_id of this WebhookNewContactPayload.  # noqa: E501

        Contact group ID  # noqa: E501

        :return: The group_id of this WebhookNewContactPayload.  # noqa: E501
        :rtype: str
        """
        return self._group_id

    @group_id.setter
    def group_id(self, group_id):
        """Sets the group_id of this WebhookNewContactPayload.

        Contact group ID  # noqa: E501

        :param group_id: The group_id of this WebhookNewContactPayload.  # noqa: E501
        :type: str
        """

        self._group_id = group_id

    @property
    def first_name(self):
        """Gets the first_name of this WebhookNewContactPayload.  # noqa: E501

        Contact first name  # noqa: E501

        :return: The first_name of this WebhookNewContactPayload.  # noqa: E501
        :rtype: str
        """
        return self._first_name

    @first_name.setter
    def first_name(self, first_name):
        """Sets the first_name of this WebhookNewContactPayload.

        Contact first name  # noqa: E501

        :param first_name: The first_name of this WebhookNewContactPayload.  # noqa: E501
        :type: str
        """

        self._first_name = first_name

    @property
    def last_name(self):
        """Gets the last_name of this WebhookNewContactPayload.  # noqa: E501

        Contact last name  # noqa: E501

        :return: The last_name of this WebhookNewContactPayload.  # noqa: E501
        :rtype: str
        """
        return self._last_name

    @last_name.setter
    def last_name(self, last_name):
        """Sets the last_name of this WebhookNewContactPayload.

        Contact last name  # noqa: E501

        :param last_name: The last_name of this WebhookNewContactPayload.  # noqa: E501
        :type: str
        """

        self._last_name = last_name

    @property
    def company(self):
        """Gets the company of this WebhookNewContactPayload.  # noqa: E501

        Contact company name  # noqa: E501

        :return: The company of this WebhookNewContactPayload.  # noqa: E501
        :rtype: str
        """
        return self._company

    @company.setter
    def company(self, company):
        """Sets the company of this WebhookNewContactPayload.

        Contact company name  # noqa: E501

        :param company: The company of this WebhookNewContactPayload.  # noqa: E501
        :type: str
        """

        self._company = company

    @property
    def primary_email_address(self):
        """Gets the primary_email_address of this WebhookNewContactPayload.  # noqa: E501

        Primary email address for contact  # noqa: E501

        :return: The primary_email_address of this WebhookNewContactPayload.  # noqa: E501
        :rtype: str
        """
        return self._primary_email_address

    @primary_email_address.setter
    def primary_email_address(self, primary_email_address):
        """Sets the primary_email_address of this WebhookNewContactPayload.

        Primary email address for contact  # noqa: E501

        :param primary_email_address: The primary_email_address of this WebhookNewContactPayload.  # noqa: E501
        :type: str
        """

        self._primary_email_address = primary_email_address

    @property
    def email_addresses(self):
        """Gets the email_addresses of this WebhookNewContactPayload.  # noqa: E501

        Email addresses for contact  # noqa: E501

        :return: The email_addresses of this WebhookNewContactPayload.  # noqa: E501
        :rtype: list[str]
        """
        return self._email_addresses

    @email_addresses.setter
    def email_addresses(self, email_addresses):
        """Sets the email_addresses of this WebhookNewContactPayload.

        Email addresses for contact  # noqa: E501

        :param email_addresses: The email_addresses of this WebhookNewContactPayload.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and email_addresses is None:  # noqa: E501
            raise ValueError("Invalid value for `email_addresses`, must not be `None`")  # noqa: E501

        self._email_addresses = email_addresses

    @property
    def tags(self):
        """Gets the tags of this WebhookNewContactPayload.  # noqa: E501

        Tags for contact  # noqa: E501

        :return: The tags of this WebhookNewContactPayload.  # noqa: E501
        :rtype: list[str]
        """
        return self._tags

    @tags.setter
    def tags(self, tags):
        """Sets the tags of this WebhookNewContactPayload.

        Tags for contact  # noqa: E501

        :param tags: The tags of this WebhookNewContactPayload.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and tags is None:  # noqa: E501
            raise ValueError("Invalid value for `tags`, must not be `None`")  # noqa: E501

        self._tags = tags

    @property
    def meta_data(self):
        """Gets the meta_data of this WebhookNewContactPayload.  # noqa: E501


        :return: The meta_data of this WebhookNewContactPayload.  # noqa: E501
        :rtype: object
        """
        return self._meta_data

    @meta_data.setter
    def meta_data(self, meta_data):
        """Sets the meta_data of this WebhookNewContactPayload.


        :param meta_data: The meta_data of this WebhookNewContactPayload.  # noqa: E501
        :type: object
        """

        self._meta_data = meta_data

    @property
    def opt_out(self):
        """Gets the opt_out of this WebhookNewContactPayload.  # noqa: E501

        Has contact opted out of emails  # noqa: E501

        :return: The opt_out of this WebhookNewContactPayload.  # noqa: E501
        :rtype: bool
        """
        return self._opt_out

    @opt_out.setter
    def opt_out(self, opt_out):
        """Sets the opt_out of this WebhookNewContactPayload.

        Has contact opted out of emails  # noqa: E501

        :param opt_out: The opt_out of this WebhookNewContactPayload.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and opt_out is None:  # noqa: E501
            raise ValueError("Invalid value for `opt_out`, must not be `None`")  # noqa: E501

        self._opt_out = opt_out

    @property
    def created_at(self):
        """Gets the created_at of this WebhookNewContactPayload.  # noqa: E501

        Date time of event creation  # noqa: E501

        :return: The created_at of this WebhookNewContactPayload.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this WebhookNewContactPayload.

        Date time of event creation  # noqa: E501

        :param created_at: The created_at of this WebhookNewContactPayload.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookNewContactPayload):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookNewContactPayload):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_new_attachment_payload.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookNewAttachmentPayload(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'message_id': 'str',
        'webhook_id': 'str',
        'webhook_name': 'str',
        'event_name': 'str',
        'attachment_id': 'str',
        'name': 'str',
        'content_type': 'str',
        'content_length': 'int'
    }

    attribute_map = {
        'message_id': 'messageId',
        'webhook_id': 'webhookId',
        'webhook_name': 'webhookName',
        'event_name': 'eventName',
        'attachment_id': 'attachmentId',
        'name': 'name',
        'content_type': 'contentType',
        'content_length': 'contentLength'
    }

    def __init__(self, message_id=None, webhook_id=None, webhook_name=None, event_name=None, attachment_id=None, name=None, content_type=None, content_length=None, local_vars_configuration=None):  # noqa: E501
        """WebhookNewAttachmentPayload - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._message_id = None
        self._webhook_id = None
        self._webhook_name = None
        self._event_name = None
        self._attachment_id = None
        self._name = None
        self._content_type = None
        self._content_length = None
        self.discriminator = None

        self.message_id = message_id
        self.webhook_id = webhook_id
        self.webhook_name = webhook_name
        self.event_name = event_name
        self.attachment_id = attachment_id
        self.name = name
        self.content_type = content_type
        self.content_length = content_length

    @property
    def message_id(self):
        """Gets the message_id of this WebhookNewAttachmentPayload.  # noqa: E501

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :return: The message_id of this WebhookNewAttachmentPayload.  # noqa: E501
        :rtype: str
        """
        return self._message_id

    @message_id.setter
    def message_id(self, message_id):
        """Sets the message_id of this WebhookNewAttachmentPayload.

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :param message_id: The message_id of this WebhookNewAttachmentPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and message_id is None:  # noqa: E501
            raise ValueError("Invalid value for `message_id`, must not be `None`")  # noqa: E501

        self._message_id = message_id

    @property
    def webhook_id(self):
        """Gets the webhook_id of this WebhookNewAttachmentPayload.  # noqa: E501

        ID of webhook entity being triggered  # noqa: E501

        :return: The webhook_id of this WebhookNewAttachmentPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_id

    @webhook_id.setter
    def webhook_id(self, webhook_id):
        """Sets the webhook_id of this WebhookNewAttachmentPayload.

        ID of webhook entity being triggered  # noqa: E501

        :param webhook_id: The webhook_id of this WebhookNewAttachmentPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and webhook_id is None:  # noqa: E501
            raise ValueError("Invalid value for `webhook_id`, must not be `None`")  # noqa: E501

        self._webhook_id = webhook_id

    @property
    def webhook_name(self):
        """Gets the webhook_name of this WebhookNewAttachmentPayload.  # noqa: E501

        Name of the webhook being triggered  # noqa: E501

        :return: The webhook_name of this WebhookNewAttachmentPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_name

    @webhook_name.setter
    def webhook_name(self, webhook_name):
        """Sets the webhook_name of this WebhookNewAttachmentPayload.

        Name of the webhook being triggered  # noqa: E501

        :param webhook_name: The webhook_name of this WebhookNewAttachmentPayload.  # noqa: E501
        :type: str
        """

        self._webhook_name = webhook_name

    @property
    def event_name(self):
        """Gets the event_name of this WebhookNewAttachmentPayload.  # noqa: E501

        Name of the event type webhook is being triggered for.  # noqa: E501

        :return: The event_name of this WebhookNewAttachmentPayload.  # noqa: E501
        :rtype: str
        """
        return self._event_name

    @event_name.setter
    def event_name(self, event_name):
        """Sets the event_name of this WebhookNewAttachmentPayload.

        Name of the event type webhook is being triggered for.  # noqa: E501

        :param event_name: The event_name of this WebhookNewAttachmentPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and event_name is None:  # noqa: E501
            raise ValueError("Invalid value for `event_name`, must not be `None`")  # noqa: E501
        allowed_values = ["EMAIL_RECEIVED", "NEW_EMAIL", "NEW_CONTACT", "NEW_ATTACHMENT", "EMAIL_OPENED", "EMAIL_READ", "DELIVERY_STATUS", "BOUNCE", "BOUNCE_RECIPIENT", "NEW_SMS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and event_name not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `event_name` ({0}), must be one of {1}"  # noqa: E501
                .format(event_name, allowed_values)
            )

        self._event_name = event_name

    @property
    def attachment_id(self):
        """Gets the attachment_id of this WebhookNewAttachmentPayload.  # noqa: E501

        ID of attachment. Use the `AttachmentController` to  # noqa: E501

        :return: The attachment_id of this WebhookNewAttachmentPayload.  # noqa: E501
        :rtype: str
        """
        return self._attachment_id

    @attachment_id.setter
    def attachment_id(self, attachment_id):
        """Sets the attachment_id of this WebhookNewAttachmentPayload.

        ID of attachment. Use the `AttachmentController` to  # noqa: E501

        :param attachment_id: The attachment_id of this WebhookNewAttachmentPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and attachment_id is None:  # noqa: E501
            raise ValueError("Invalid value for `attachment_id`, must not be `None`")  # noqa: E501

        self._attachment_id = attachment_id

    @property
    def name(self):
        """Gets the name of this WebhookNewAttachmentPayload.  # noqa: E501

        Filename of the attachment if present  # noqa: E501

        :return: The name of this WebhookNewAttachmentPayload.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this WebhookNewAttachmentPayload.

        Filename of the attachment if present  # noqa: E501

        :param name: The name of this WebhookNewAttachmentPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    @property
    def content_type(self):
        """Gets the content_type of this WebhookNewAttachmentPayload.  # noqa: E501

        Content type of attachment such as 'image/png' or 'application/pdf  # noqa: E501

        :return: The content_type of this WebhookNewAttachmentPayload.  # noqa: E501
        :rtype: str
        """
        return self._content_type

    @content_type.setter
    def content_type(self, content_type):
        """Sets the content_type of this WebhookNewAttachmentPayload.

        Content type of attachment such as 'image/png' or 'application/pdf  # noqa: E501

        :param content_type: The content_type of this WebhookNewAttachmentPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and content_type is None:  # noqa: E501
            raise ValueError("Invalid value for `content_type`, must not be `None`")  # noqa: E501

        self._content_type = content_type

    @property
    def content_length(self):
        """Gets the content_length of this WebhookNewAttachmentPayload.  # noqa: E501

        Size of attachment in bytes  # noqa: E501

        :return: The content_length of this WebhookNewAttachmentPayload.  # noqa: E501
        :rtype: int
        """
        return self._content_length

    @content_length.setter
    def content_length(self, content_length):
        """Sets the content_length of this WebhookNewAttachmentPayload.

        Size of attachment in bytes  # noqa: E501

        :param content_length: The content_length of this WebhookNewAttachmentPayload.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and content_length is None:  # noqa: E501
            raise ValueError("Invalid value for `content_length`, must not be `None`")  # noqa: E501

        self._content_length = content_length

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookNewAttachmentPayload):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookNewAttachmentPayload):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_headers.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookHeaders(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'headers': 'list[WebhookHeaderNameValue]'
    }

    attribute_map = {
        'headers': 'headers'
    }

    def __init__(self, headers=None, local_vars_configuration=None):  # noqa: E501
        """WebhookHeaders - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._headers = None
        self.discriminator = None

        self.headers = headers

    @property
    def headers(self):
        """Gets the headers of this WebhookHeaders.  # noqa: E501

        List of header name value pairs to include with webhook requests  # noqa: E501

        :return: The headers of this WebhookHeaders.  # noqa: E501
        :rtype: list[WebhookHeaderNameValue]
        """
        return self._headers

    @headers.setter
    def headers(self, headers):
        """Sets the headers of this WebhookHeaders.

        List of header name value pairs to include with webhook requests  # noqa: E501

        :param headers: The headers of this WebhookHeaders.  # noqa: E501
        :type: list[WebhookHeaderNameValue]
        """
        if self.local_vars_configuration.client_side_validation and headers is None:  # noqa: E501
            raise ValueError("Invalid value for `headers`, must not be `None`")  # noqa: E501

        self._headers = headers

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookHeaders):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookHeaders):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_header_name_value.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookHeaderNameValue(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'name': 'str',
        'value': 'str'
    }

    attribute_map = {
        'name': 'name',
        'value': 'value'
    }

    def __init__(self, name=None, value=None, local_vars_configuration=None):  # noqa: E501
        """WebhookHeaderNameValue - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._name = None
        self._value = None
        self.discriminator = None

        self.name = name
        self.value = value

    @property
    def name(self):
        """Gets the name of this WebhookHeaderNameValue.  # noqa: E501

        Name of header  # noqa: E501

        :return: The name of this WebhookHeaderNameValue.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this WebhookHeaderNameValue.

        Name of header  # noqa: E501

        :param name: The name of this WebhookHeaderNameValue.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    @property
    def value(self):
        """Gets the value of this WebhookHeaderNameValue.  # noqa: E501

        Value of header  # noqa: E501

        :return: The value of this WebhookHeaderNameValue.  # noqa: E501
        :rtype: str
        """
        return self._value

    @value.setter
    def value(self, value):
        """Sets the value of this WebhookHeaderNameValue.

        Value of header  # noqa: E501

        :param value: The value of this WebhookHeaderNameValue.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and value is None:  # noqa: E501
            raise ValueError("Invalid value for `value`, must not be `None`")  # noqa: E501

        self._value = value

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookHeaderNameValue):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookHeaderNameValue):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_email_read_payload.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookEmailReadPayload(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'message_id': 'str',
        'webhook_id': 'str',
        'event_name': 'str',
        'webhook_name': 'str',
        'email_id': 'str',
        'inbox_id': 'str',
        'email_is_read': 'bool',
        'created_at': 'datetime'
    }

    attribute_map = {
        'message_id': 'messageId',
        'webhook_id': 'webhookId',
        'event_name': 'eventName',
        'webhook_name': 'webhookName',
        'email_id': 'emailId',
        'inbox_id': 'inboxId',
        'email_is_read': 'emailIsRead',
        'created_at': 'createdAt'
    }

    def __init__(self, message_id=None, webhook_id=None, event_name=None, webhook_name=None, email_id=None, inbox_id=None, email_is_read=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """WebhookEmailReadPayload - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._message_id = None
        self._webhook_id = None
        self._event_name = None
        self._webhook_name = None
        self._email_id = None
        self._inbox_id = None
        self._email_is_read = None
        self._created_at = None
        self.discriminator = None

        self.message_id = message_id
        self.webhook_id = webhook_id
        self.event_name = event_name
        self.webhook_name = webhook_name
        self.email_id = email_id
        self.inbox_id = inbox_id
        self.email_is_read = email_is_read
        self.created_at = created_at

    @property
    def message_id(self):
        """Gets the message_id of this WebhookEmailReadPayload.  # noqa: E501

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :return: The message_id of this WebhookEmailReadPayload.  # noqa: E501
        :rtype: str
        """
        return self._message_id

    @message_id.setter
    def message_id(self, message_id):
        """Sets the message_id of this WebhookEmailReadPayload.

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :param message_id: The message_id of this WebhookEmailReadPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and message_id is None:  # noqa: E501
            raise ValueError("Invalid value for `message_id`, must not be `None`")  # noqa: E501

        self._message_id = message_id

    @property
    def webhook_id(self):
        """Gets the webhook_id of this WebhookEmailReadPayload.  # noqa: E501

        ID of webhook entity being triggered  # noqa: E501

        :return: The webhook_id of this WebhookEmailReadPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_id

    @webhook_id.setter
    def webhook_id(self, webhook_id):
        """Sets the webhook_id of this WebhookEmailReadPayload.

        ID of webhook entity being triggered  # noqa: E501

        :param webhook_id: The webhook_id of this WebhookEmailReadPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and webhook_id is None:  # noqa: E501
            raise ValueError("Invalid value for `webhook_id`, must not be `None`")  # noqa: E501

        self._webhook_id = webhook_id

    @property
    def event_name(self):
        """Gets the event_name of this WebhookEmailReadPayload.  # noqa: E501

        Name of the event type webhook is being triggered for.  # noqa: E501

        :return: The event_name of this WebhookEmailReadPayload.  # noqa: E501
        :rtype: str
        """
        return self._event_name

    @event_name.setter
    def event_name(self, event_name):
        """Sets the event_name of this WebhookEmailReadPayload.

        Name of the event type webhook is being triggered for.  # noqa: E501

        :param event_name: The event_name of this WebhookEmailReadPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and event_name is None:  # noqa: E501
            raise ValueError("Invalid value for `event_name`, must not be `None`")  # noqa: E501
        allowed_values = ["EMAIL_RECEIVED", "NEW_EMAIL", "NEW_CONTACT", "NEW_ATTACHMENT", "EMAIL_OPENED", "EMAIL_READ", "DELIVERY_STATUS", "BOUNCE", "BOUNCE_RECIPIENT", "NEW_SMS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and event_name not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `event_name` ({0}), must be one of {1}"  # noqa: E501
                .format(event_name, allowed_values)
            )

        self._event_name = event_name

    @property
    def webhook_name(self):
        """Gets the webhook_name of this WebhookEmailReadPayload.  # noqa: E501

        Name of the webhook being triggered  # noqa: E501

        :return: The webhook_name of this WebhookEmailReadPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_name

    @webhook_name.setter
    def webhook_name(self, webhook_name):
        """Sets the webhook_name of this WebhookEmailReadPayload.

        Name of the webhook being triggered  # noqa: E501

        :param webhook_name: The webhook_name of this WebhookEmailReadPayload.  # noqa: E501
        :type: str
        """

        self._webhook_name = webhook_name

    @property
    def email_id(self):
        """Gets the email_id of this WebhookEmailReadPayload.  # noqa: E501

        ID of the email that was received. Use this ID for fetching the email with the `EmailController`.  # noqa: E501

        :return: The email_id of this WebhookEmailReadPayload.  # noqa: E501
        :rtype: str
        """
        return self._email_id

    @email_id.setter
    def email_id(self, email_id):
        """Sets the email_id of this WebhookEmailReadPayload.

        ID of the email that was received. Use this ID for fetching the email with the `EmailController`.  # noqa: E501

        :param email_id: The email_id of this WebhookEmailReadPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_id is None:  # noqa: E501
            raise ValueError("Invalid value for `email_id`, must not be `None`")  # noqa: E501

        self._email_id = email_id

    @property
    def inbox_id(self):
        """Gets the inbox_id of this WebhookEmailReadPayload.  # noqa: E501

        Id of the inbox  # noqa: E501

        :return: The inbox_id of this WebhookEmailReadPayload.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this WebhookEmailReadPayload.

        Id of the inbox  # noqa: E501

        :param inbox_id: The inbox_id of this WebhookEmailReadPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def email_is_read(self):
        """Gets the email_is_read of this WebhookEmailReadPayload.  # noqa: E501

        Is the email read  # noqa: E501

        :return: The email_is_read of this WebhookEmailReadPayload.  # noqa: E501
        :rtype: bool
        """
        return self._email_is_read

    @email_is_read.setter
    def email_is_read(self, email_is_read):
        """Sets the email_is_read of this WebhookEmailReadPayload.

        Is the email read  # noqa: E501

        :param email_is_read: The email_is_read of this WebhookEmailReadPayload.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and email_is_read is None:  # noqa: E501
            raise ValueError("Invalid value for `email_is_read`, must not be `None`")  # noqa: E501

        self._email_is_read = email_is_read

    @property
    def created_at(self):
        """Gets the created_at of this WebhookEmailReadPayload.  # noqa: E501

        Date time of event creation  # noqa: E501

        :return: The created_at of this WebhookEmailReadPayload.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this WebhookEmailReadPayload.

        Date time of event creation  # noqa: E501

        :param created_at: The created_at of this WebhookEmailReadPayload.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookEmailReadPayload):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookEmailReadPayload):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_email_opened_payload.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookEmailOpenedPayload(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'message_id': 'str',
        'webhook_id': 'str',
        'event_name': 'str',
        'webhook_name': 'str',
        'inbox_id': 'str',
        'pixel_id': 'str',
        'sent_email_id': 'str',
        'recipient': 'str',
        'created_at': 'datetime'
    }

    attribute_map = {
        'message_id': 'messageId',
        'webhook_id': 'webhookId',
        'event_name': 'eventName',
        'webhook_name': 'webhookName',
        'inbox_id': 'inboxId',
        'pixel_id': 'pixelId',
        'sent_email_id': 'sentEmailId',
        'recipient': 'recipient',
        'created_at': 'createdAt'
    }

    def __init__(self, message_id=None, webhook_id=None, event_name=None, webhook_name=None, inbox_id=None, pixel_id=None, sent_email_id=None, recipient=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """WebhookEmailOpenedPayload - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._message_id = None
        self._webhook_id = None
        self._event_name = None
        self._webhook_name = None
        self._inbox_id = None
        self._pixel_id = None
        self._sent_email_id = None
        self._recipient = None
        self._created_at = None
        self.discriminator = None

        self.message_id = message_id
        self.webhook_id = webhook_id
        self.event_name = event_name
        self.webhook_name = webhook_name
        self.inbox_id = inbox_id
        self.pixel_id = pixel_id
        self.sent_email_id = sent_email_id
        self.recipient = recipient
        self.created_at = created_at

    @property
    def message_id(self):
        """Gets the message_id of this WebhookEmailOpenedPayload.  # noqa: E501

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :return: The message_id of this WebhookEmailOpenedPayload.  # noqa: E501
        :rtype: str
        """
        return self._message_id

    @message_id.setter
    def message_id(self, message_id):
        """Sets the message_id of this WebhookEmailOpenedPayload.

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :param message_id: The message_id of this WebhookEmailOpenedPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and message_id is None:  # noqa: E501
            raise ValueError("Invalid value for `message_id`, must not be `None`")  # noqa: E501

        self._message_id = message_id

    @property
    def webhook_id(self):
        """Gets the webhook_id of this WebhookEmailOpenedPayload.  # noqa: E501

        ID of webhook entity being triggered  # noqa: E501

        :return: The webhook_id of this WebhookEmailOpenedPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_id

    @webhook_id.setter
    def webhook_id(self, webhook_id):
        """Sets the webhook_id of this WebhookEmailOpenedPayload.

        ID of webhook entity being triggered  # noqa: E501

        :param webhook_id: The webhook_id of this WebhookEmailOpenedPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and webhook_id is None:  # noqa: E501
            raise ValueError("Invalid value for `webhook_id`, must not be `None`")  # noqa: E501

        self._webhook_id = webhook_id

    @property
    def event_name(self):
        """Gets the event_name of this WebhookEmailOpenedPayload.  # noqa: E501

        Name of the event type webhook is being triggered for.  # noqa: E501

        :return: The event_name of this WebhookEmailOpenedPayload.  # noqa: E501
        :rtype: str
        """
        return self._event_name

    @event_name.setter
    def event_name(self, event_name):
        """Sets the event_name of this WebhookEmailOpenedPayload.

        Name of the event type webhook is being triggered for.  # noqa: E501

        :param event_name: The event_name of this WebhookEmailOpenedPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and event_name is None:  # noqa: E501
            raise ValueError("Invalid value for `event_name`, must not be `None`")  # noqa: E501
        allowed_values = ["EMAIL_RECEIVED", "NEW_EMAIL", "NEW_CONTACT", "NEW_ATTACHMENT", "EMAIL_OPENED", "EMAIL_READ", "DELIVERY_STATUS", "BOUNCE", "BOUNCE_RECIPIENT", "NEW_SMS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and event_name not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `event_name` ({0}), must be one of {1}"  # noqa: E501
                .format(event_name, allowed_values)
            )

        self._event_name = event_name

    @property
    def webhook_name(self):
        """Gets the webhook_name of this WebhookEmailOpenedPayload.  # noqa: E501

        Name of the webhook being triggered  # noqa: E501

        :return: The webhook_name of this WebhookEmailOpenedPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_name

    @webhook_name.setter
    def webhook_name(self, webhook_name):
        """Sets the webhook_name of this WebhookEmailOpenedPayload.

        Name of the webhook being triggered  # noqa: E501

        :param webhook_name: The webhook_name of this WebhookEmailOpenedPayload.  # noqa: E501
        :type: str
        """

        self._webhook_name = webhook_name

    @property
    def inbox_id(self):
        """Gets the inbox_id of this WebhookEmailOpenedPayload.  # noqa: E501

        Id of the inbox  # noqa: E501

        :return: The inbox_id of this WebhookEmailOpenedPayload.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this WebhookEmailOpenedPayload.

        Id of the inbox  # noqa: E501

        :param inbox_id: The inbox_id of this WebhookEmailOpenedPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def pixel_id(self):
        """Gets the pixel_id of this WebhookEmailOpenedPayload.  # noqa: E501

        ID of the tracking pixel  # noqa: E501

        :return: The pixel_id of this WebhookEmailOpenedPayload.  # noqa: E501
        :rtype: str
        """
        return self._pixel_id

    @pixel_id.setter
    def pixel_id(self, pixel_id):
        """Sets the pixel_id of this WebhookEmailOpenedPayload.

        ID of the tracking pixel  # noqa: E501

        :param pixel_id: The pixel_id of this WebhookEmailOpenedPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and pixel_id is None:  # noqa: E501
            raise ValueError("Invalid value for `pixel_id`, must not be `None`")  # noqa: E501

        self._pixel_id = pixel_id

    @property
    def sent_email_id(self):
        """Gets the sent_email_id of this WebhookEmailOpenedPayload.  # noqa: E501

        ID of sent email  # noqa: E501

        :return: The sent_email_id of this WebhookEmailOpenedPayload.  # noqa: E501
        :rtype: str
        """
        return self._sent_email_id

    @sent_email_id.setter
    def sent_email_id(self, sent_email_id):
        """Sets the sent_email_id of this WebhookEmailOpenedPayload.

        ID of sent email  # noqa: E501

        :param sent_email_id: The sent_email_id of this WebhookEmailOpenedPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and sent_email_id is None:  # noqa: E501
            raise ValueError("Invalid value for `sent_email_id`, must not be `None`")  # noqa: E501

        self._sent_email_id = sent_email_id

    @property
    def recipient(self):
        """Gets the recipient of this WebhookEmailOpenedPayload.  # noqa: E501

        Email address for the recipient of the tracking pixel  # noqa: E501

        :return: The recipient of this WebhookEmailOpenedPayload.  # noqa: E501
        :rtype: str
        """
        return self._recipient

    @recipient.setter
    def recipient(self, recipient):
        """Sets the recipient of this WebhookEmailOpenedPayload.

        Email address for the recipient of the tracking pixel  # noqa: E501

        :param recipient: The recipient of this WebhookEmailOpenedPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and recipient is None:  # noqa: E501
            raise ValueError("Invalid value for `recipient`, must not be `None`")  # noqa: E501

        self._recipient = recipient

    @property
    def created_at(self):
        """Gets the created_at of this WebhookEmailOpenedPayload.  # noqa: E501

        Date time of event creation  # noqa: E501

        :return: The created_at of this WebhookEmailOpenedPayload.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this WebhookEmailOpenedPayload.

        Date time of event creation  # noqa: E501

        :param created_at: The created_at of this WebhookEmailOpenedPayload.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookEmailOpenedPayload):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookEmailOpenedPayload):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'basic_auth': 'bool',
        'name': 'str',
        'phone_id': 'str',
        'inbox_id': 'str',
        'request_body_template': 'str',
        'url': 'str',
        'method': 'str',
        'payload_json_schema': 'str',
        'created_at': 'datetime',
        'updated_at': 'datetime',
        'event_name': 'str',
        'request_headers': 'WebhookHeaders',
        'ignore_insecure_ssl_certificates': 'bool',
        'use_static_ip_range': 'bool'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'basic_auth': 'basicAuth',
        'name': 'name',
        'phone_id': 'phoneId',
        'inbox_id': 'inboxId',
        'request_body_template': 'requestBodyTemplate',
        'url': 'url',
        'method': 'method',
        'payload_json_schema': 'payloadJsonSchema',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt',
        'event_name': 'eventName',
        'request_headers': 'requestHeaders',
        'ignore_insecure_ssl_certificates': 'ignoreInsecureSslCertificates',
        'use_static_ip_range': 'useStaticIpRange'
    }

    def __init__(self, id=None, user_id=None, basic_auth=None, name=None, phone_id=None, inbox_id=None, request_body_template=None, url=None, method=None, payload_json_schema=None, created_at=None, updated_at=None, event_name=None, request_headers=None, ignore_insecure_ssl_certificates=None, use_static_ip_range=None, local_vars_configuration=None):  # noqa: E501
        """WebhookDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._basic_auth = None
        self._name = None
        self._phone_id = None
        self._inbox_id = None
        self._request_body_template = None
        self._url = None
        self._method = None
        self._payload_json_schema = None
        self._created_at = None
        self._updated_at = None
        self._event_name = None
        self._request_headers = None
        self._ignore_insecure_ssl_certificates = None
        self._use_static_ip_range = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        self.basic_auth = basic_auth
        self.name = name
        self.phone_id = phone_id
        self.inbox_id = inbox_id
        self.request_body_template = request_body_template
        self.url = url
        self.method = method
        self.payload_json_schema = payload_json_schema
        self.created_at = created_at
        self.updated_at = updated_at
        self.event_name = event_name
        if request_headers is not None:
            self.request_headers = request_headers
        self.ignore_insecure_ssl_certificates = ignore_insecure_ssl_certificates
        self.use_static_ip_range = use_static_ip_range

    @property
    def id(self):
        """Gets the id of this WebhookDto.  # noqa: E501

        ID of the Webhook  # noqa: E501

        :return: The id of this WebhookDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this WebhookDto.

        ID of the Webhook  # noqa: E501

        :param id: The id of this WebhookDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this WebhookDto.  # noqa: E501

        User ID of the Webhook  # noqa: E501

        :return: The user_id of this WebhookDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this WebhookDto.

        User ID of the Webhook  # noqa: E501

        :param user_id: The user_id of this WebhookDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def basic_auth(self):
        """Gets the basic_auth of this WebhookDto.  # noqa: E501

        Does webhook expect basic authentication? If true it means you created this webhook with a username and password. MailSlurp will use these in the URL to authenticate itself.  # noqa: E501

        :return: The basic_auth of this WebhookDto.  # noqa: E501
        :rtype: bool
        """
        return self._basic_auth

    @basic_auth.setter
    def basic_auth(self, basic_auth):
        """Sets the basic_auth of this WebhookDto.

        Does webhook expect basic authentication? If true it means you created this webhook with a username and password. MailSlurp will use these in the URL to authenticate itself.  # noqa: E501

        :param basic_auth: The basic_auth of this WebhookDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and basic_auth is None:  # noqa: E501
            raise ValueError("Invalid value for `basic_auth`, must not be `None`")  # noqa: E501

        self._basic_auth = basic_auth

    @property
    def name(self):
        """Gets the name of this WebhookDto.  # noqa: E501

        Name of the webhook  # noqa: E501

        :return: The name of this WebhookDto.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this WebhookDto.

        Name of the webhook  # noqa: E501

        :param name: The name of this WebhookDto.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def phone_id(self):
        """Gets the phone_id of this WebhookDto.  # noqa: E501

        The phoneNumberId that the Webhook will be triggered by. If null then webhook triggered at account level or inbox level if inboxId set  # noqa: E501

        :return: The phone_id of this WebhookDto.  # noqa: E501
        :rtype: str
        """
        return self._phone_id

    @phone_id.setter
    def phone_id(self, phone_id):
        """Sets the phone_id of this WebhookDto.

        The phoneNumberId that the Webhook will be triggered by. If null then webhook triggered at account level or inbox level if inboxId set  # noqa: E501

        :param phone_id: The phone_id of this WebhookDto.  # noqa: E501
        :type: str
        """

        self._phone_id = phone_id

    @property
    def inbox_id(self):
        """Gets the inbox_id of this WebhookDto.  # noqa: E501

        The inbox that the Webhook will be triggered by. If null then webhook triggered at account level or phone level if phoneId set  # noqa: E501

        :return: The inbox_id of this WebhookDto.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this WebhookDto.

        The inbox that the Webhook will be triggered by. If null then webhook triggered at account level or phone level if phoneId set  # noqa: E501

        :param inbox_id: The inbox_id of this WebhookDto.  # noqa: E501
        :type: str
        """

        self._inbox_id = inbox_id

    @property
    def request_body_template(self):
        """Gets the request_body_template of this WebhookDto.  # noqa: E501

        Request body template for HTTP request that will be sent for the webhook. Use Moustache style template variables to insert values from the original event payload.  # noqa: E501

        :return: The request_body_template of this WebhookDto.  # noqa: E501
        :rtype: str
        """
        return self._request_body_template

    @request_body_template.setter
    def request_body_template(self, request_body_template):
        """Sets the request_body_template of this WebhookDto.

        Request body template for HTTP request that will be sent for the webhook. Use Moustache style template variables to insert values from the original event payload.  # noqa: E501

        :param request_body_template: The request_body_template of this WebhookDto.  # noqa: E501
        :type: str
        """

        self._request_body_template = request_body_template

    @property
    def url(self):
        """Gets the url of this WebhookDto.  # noqa: E501

        URL of your server that the webhook will be sent to. The schema of the JSON that is sent is described by the payloadJsonSchema.  # noqa: E501

        :return: The url of this WebhookDto.  # noqa: E501
        :rtype: str
        """
        return self._url

    @url.setter
    def url(self, url):
        """Sets the url of this WebhookDto.

        URL of your server that the webhook will be sent to. The schema of the JSON that is sent is described by the payloadJsonSchema.  # noqa: E501

        :param url: The url of this WebhookDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and url is None:  # noqa: E501
            raise ValueError("Invalid value for `url`, must not be `None`")  # noqa: E501

        self._url = url

    @property
    def method(self):
        """Gets the method of this WebhookDto.  # noqa: E501

        HTTP method that your server endpoint must listen for  # noqa: E501

        :return: The method of this WebhookDto.  # noqa: E501
        :rtype: str
        """
        return self._method

    @method.setter
    def method(self, method):
        """Sets the method of this WebhookDto.

        HTTP method that your server endpoint must listen for  # noqa: E501

        :param method: The method of this WebhookDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and method is None:  # noqa: E501
            raise ValueError("Invalid value for `method`, must not be `None`")  # noqa: E501
        allowed_values = ["POST", "DELETE", "GET", "PUT", "PATCH", "HEAD", "OPTIONS", "TRACE"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and method not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `method` ({0}), must be one of {1}"  # noqa: E501
                .format(method, allowed_values)
            )

        self._method = method

    @property
    def payload_json_schema(self):
        """Gets the payload_json_schema of this WebhookDto.  # noqa: E501

        Deprecated. Fetch JSON Schema for webhook using the getJsonSchemaForWebhookPayload method  # noqa: E501

        :return: The payload_json_schema of this WebhookDto.  # noqa: E501
        :rtype: str
        """
        return self._payload_json_schema

    @payload_json_schema.setter
    def payload_json_schema(self, payload_json_schema):
        """Sets the payload_json_schema of this WebhookDto.

        Deprecated. Fetch JSON Schema for webhook using the getJsonSchemaForWebhookPayload method  # noqa: E501

        :param payload_json_schema: The payload_json_schema of this WebhookDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and payload_json_schema is None:  # noqa: E501
            raise ValueError("Invalid value for `payload_json_schema`, must not be `None`")  # noqa: E501

        self._payload_json_schema = payload_json_schema

    @property
    def created_at(self):
        """Gets the created_at of this WebhookDto.  # noqa: E501

        When the webhook was created  # noqa: E501

        :return: The created_at of this WebhookDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this WebhookDto.

        When the webhook was created  # noqa: E501

        :param created_at: The created_at of this WebhookDto.  # noqa: E501
        :type: datetime
        """

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this WebhookDto.  # noqa: E501


        :return: The updated_at of this WebhookDto.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this WebhookDto.


        :param updated_at: The updated_at of this WebhookDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    @property
    def event_name(self):
        """Gets the event_name of this WebhookDto.  # noqa: E501

        Webhook trigger event name  # noqa: E501

        :return: The event_name of this WebhookDto.  # noqa: E501
        :rtype: str
        """
        return self._event_name

    @event_name.setter
    def event_name(self, event_name):
        """Sets the event_name of this WebhookDto.

        Webhook trigger event name  # noqa: E501

        :param event_name: The event_name of this WebhookDto.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"EMAIL_RECEIVED", "NEW_EMAIL", "NEW_CONTACT", "NEW_ATTACHMENT", "EMAIL_OPENED", "EMAIL_READ", "DELIVERY_STATUS", "BOUNCE", "BOUNCE_RECIPIENT", "NEW_SMS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and event_name not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `event_name` ({0}), must be one of {1}"  # noqa: E501
                .format(event_name, allowed_values)
            )

        self._event_name = event_name

    @property
    def request_headers(self):
        """Gets the request_headers of this WebhookDto.  # noqa: E501


        :return: The request_headers of this WebhookDto.  # noqa: E501
        :rtype: WebhookHeaders
        """
        return self._request_headers

    @request_headers.setter
    def request_headers(self, request_headers):
        """Sets the request_headers of this WebhookDto.


        :param request_headers: The request_headers of this WebhookDto.  # noqa: E501
        :type: WebhookHeaders
        """

        self._request_headers = request_headers

    @property
    def ignore_insecure_ssl_certificates(self):
        """Gets the ignore_insecure_ssl_certificates of this WebhookDto.  # noqa: E501

        Should notifier ignore insecure SSL certificates  # noqa: E501

        :return: The ignore_insecure_ssl_certificates of this WebhookDto.  # noqa: E501
        :rtype: bool
        """
        return self._ignore_insecure_ssl_certificates

    @ignore_insecure_ssl_certificates.setter
    def ignore_insecure_ssl_certificates(self, ignore_insecure_ssl_certificates):
        """Sets the ignore_insecure_ssl_certificates of this WebhookDto.

        Should notifier ignore insecure SSL certificates  # noqa: E501

        :param ignore_insecure_ssl_certificates: The ignore_insecure_ssl_certificates of this WebhookDto.  # noqa: E501
        :type: bool
        """

        self._ignore_insecure_ssl_certificates = ignore_insecure_ssl_certificates

    @property
    def use_static_ip_range(self):
        """Gets the use_static_ip_range of this WebhookDto.  # noqa: E501

        Should notifier use static IP range when sending webhook payload  # noqa: E501

        :return: The use_static_ip_range of this WebhookDto.  # noqa: E501
        :rtype: bool
        """
        return self._use_static_ip_range

    @use_static_ip_range.setter
    def use_static_ip_range(self, use_static_ip_range):
        """Sets the use_static_ip_range of this WebhookDto.

        Should notifier use static IP range when sending webhook payload  # noqa: E501

        :param use_static_ip_range: The use_static_ip_range of this WebhookDto.  # noqa: E501
        :type: bool
        """

        self._use_static_ip_range = use_static_ip_range

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_delivery_status_payload.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookDeliveryStatusPayload(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'message_id': 'str',
        'webhook_id': 'str',
        'event_name': 'str',
        'webhook_name': 'str',
        'id': 'str',
        'user_id': 'str',
        'sent_id': 'str',
        'remote_mta_ip': 'str',
        'inbox_id': 'str',
        'reporting_mta': 'str',
        'recipients': 'list[str]',
        'smtp_response': 'str',
        'smtp_status_code': 'int',
        'processing_time_millis': 'int',
        'received': 'datetime',
        'subject': 'str'
    }

    attribute_map = {
        'message_id': 'messageId',
        'webhook_id': 'webhookId',
        'event_name': 'eventName',
        'webhook_name': 'webhookName',
        'id': 'id',
        'user_id': 'userId',
        'sent_id': 'sentId',
        'remote_mta_ip': 'remoteMtaIp',
        'inbox_id': 'inboxId',
        'reporting_mta': 'reportingMta',
        'recipients': 'recipients',
        'smtp_response': 'smtpResponse',
        'smtp_status_code': 'smtpStatusCode',
        'processing_time_millis': 'processingTimeMillis',
        'received': 'received',
        'subject': 'subject'
    }

    def __init__(self, message_id=None, webhook_id=None, event_name=None, webhook_name=None, id=None, user_id=None, sent_id=None, remote_mta_ip=None, inbox_id=None, reporting_mta=None, recipients=None, smtp_response=None, smtp_status_code=None, processing_time_millis=None, received=None, subject=None, local_vars_configuration=None):  # noqa: E501
        """WebhookDeliveryStatusPayload - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._message_id = None
        self._webhook_id = None
        self._event_name = None
        self._webhook_name = None
        self._id = None
        self._user_id = None
        self._sent_id = None
        self._remote_mta_ip = None
        self._inbox_id = None
        self._reporting_mta = None
        self._recipients = None
        self._smtp_response = None
        self._smtp_status_code = None
        self._processing_time_millis = None
        self._received = None
        self._subject = None
        self.discriminator = None

        self.message_id = message_id
        self.webhook_id = webhook_id
        self.event_name = event_name
        self.webhook_name = webhook_name
        self.id = id
        self.user_id = user_id
        self.sent_id = sent_id
        self.remote_mta_ip = remote_mta_ip
        self.inbox_id = inbox_id
        self.reporting_mta = reporting_mta
        self.recipients = recipients
        self.smtp_response = smtp_response
        self.smtp_status_code = smtp_status_code
        self.processing_time_millis = processing_time_millis
        self.received = received
        self.subject = subject

    @property
    def message_id(self):
        """Gets the message_id of this WebhookDeliveryStatusPayload.  # noqa: E501

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :return: The message_id of this WebhookDeliveryStatusPayload.  # noqa: E501
        :rtype: str
        """
        return self._message_id

    @message_id.setter
    def message_id(self, message_id):
        """Sets the message_id of this WebhookDeliveryStatusPayload.

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :param message_id: The message_id of this WebhookDeliveryStatusPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and message_id is None:  # noqa: E501
            raise ValueError("Invalid value for `message_id`, must not be `None`")  # noqa: E501

        self._message_id = message_id

    @property
    def webhook_id(self):
        """Gets the webhook_id of this WebhookDeliveryStatusPayload.  # noqa: E501

        ID of webhook entity being triggered  # noqa: E501

        :return: The webhook_id of this WebhookDeliveryStatusPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_id

    @webhook_id.setter
    def webhook_id(self, webhook_id):
        """Sets the webhook_id of this WebhookDeliveryStatusPayload.

        ID of webhook entity being triggered  # noqa: E501

        :param webhook_id: The webhook_id of this WebhookDeliveryStatusPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and webhook_id is None:  # noqa: E501
            raise ValueError("Invalid value for `webhook_id`, must not be `None`")  # noqa: E501

        self._webhook_id = webhook_id

    @property
    def event_name(self):
        """Gets the event_name of this WebhookDeliveryStatusPayload.  # noqa: E501

        Name of the event type webhook is being triggered for.  # noqa: E501

        :return: The event_name of this WebhookDeliveryStatusPayload.  # noqa: E501
        :rtype: str
        """
        return self._event_name

    @event_name.setter
    def event_name(self, event_name):
        """Sets the event_name of this WebhookDeliveryStatusPayload.

        Name of the event type webhook is being triggered for.  # noqa: E501

        :param event_name: The event_name of this WebhookDeliveryStatusPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and event_name is None:  # noqa: E501
            raise ValueError("Invalid value for `event_name`, must not be `None`")  # noqa: E501
        allowed_values = ["EMAIL_RECEIVED", "NEW_EMAIL", "NEW_CONTACT", "NEW_ATTACHMENT", "EMAIL_OPENED", "EMAIL_READ", "DELIVERY_STATUS", "BOUNCE", "BOUNCE_RECIPIENT", "NEW_SMS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and event_name not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `event_name` ({0}), must be one of {1}"  # noqa: E501
                .format(event_name, allowed_values)
            )

        self._event_name = event_name

    @property
    def webhook_name(self):
        """Gets the webhook_name of this WebhookDeliveryStatusPayload.  # noqa: E501

        Name of the webhook being triggered  # noqa: E501

        :return: The webhook_name of this WebhookDeliveryStatusPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_name

    @webhook_name.setter
    def webhook_name(self, webhook_name):
        """Sets the webhook_name of this WebhookDeliveryStatusPayload.

        Name of the webhook being triggered  # noqa: E501

        :param webhook_name: The webhook_name of this WebhookDeliveryStatusPayload.  # noqa: E501
        :type: str
        """

        self._webhook_name = webhook_name

    @property
    def id(self):
        """Gets the id of this WebhookDeliveryStatusPayload.  # noqa: E501

        ID of delivery status  # noqa: E501

        :return: The id of this WebhookDeliveryStatusPayload.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this WebhookDeliveryStatusPayload.

        ID of delivery status  # noqa: E501

        :param id: The id of this WebhookDeliveryStatusPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this WebhookDeliveryStatusPayload.  # noqa: E501

        User ID of event  # noqa: E501

        :return: The user_id of this WebhookDeliveryStatusPayload.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this WebhookDeliveryStatusPayload.

        User ID of event  # noqa: E501

        :param user_id: The user_id of this WebhookDeliveryStatusPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def sent_id(self):
        """Gets the sent_id of this WebhookDeliveryStatusPayload.  # noqa: E501

        ID of sent email  # noqa: E501

        :return: The sent_id of this WebhookDeliveryStatusPayload.  # noqa: E501
        :rtype: str
        """
        return self._sent_id

    @sent_id.setter
    def sent_id(self, sent_id):
        """Sets the sent_id of this WebhookDeliveryStatusPayload.

        ID of sent email  # noqa: E501

        :param sent_id: The sent_id of this WebhookDeliveryStatusPayload.  # noqa: E501
        :type: str
        """

        self._sent_id = sent_id

    @property
    def remote_mta_ip(self):
        """Gets the remote_mta_ip of this WebhookDeliveryStatusPayload.  # noqa: E501

        IP address of the remote Mail Transfer Agent  # noqa: E501

        :return: The remote_mta_ip of this WebhookDeliveryStatusPayload.  # noqa: E501
        :rtype: str
        """
        return self._remote_mta_ip

    @remote_mta_ip.setter
    def remote_mta_ip(self, remote_mta_ip):
        """Sets the remote_mta_ip of this WebhookDeliveryStatusPayload.

        IP address of the remote Mail Transfer Agent  # noqa: E501

        :param remote_mta_ip: The remote_mta_ip of this WebhookDeliveryStatusPayload.  # noqa: E501
        :type: str
        """

        self._remote_mta_ip = remote_mta_ip

    @property
    def inbox_id(self):
        """Gets the inbox_id of this WebhookDeliveryStatusPayload.  # noqa: E501

        Id of the inbox  # noqa: E501

        :return: The inbox_id of this WebhookDeliveryStatusPayload.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this WebhookDeliveryStatusPayload.

        Id of the inbox  # noqa: E501

        :param inbox_id: The inbox_id of this WebhookDeliveryStatusPayload.  # noqa: E501
        :type: str
        """

        self._inbox_id = inbox_id

    @property
    def reporting_mta(self):
        """Gets the reporting_mta of this WebhookDeliveryStatusPayload.  # noqa: E501

        Mail Transfer Agent reporting delivery status  # noqa: E501

        :return: The reporting_mta of this WebhookDeliveryStatusPayload.  # noqa: E501
        :rtype: str
        """
        return self._reporting_mta

    @reporting_mta.setter
    def reporting_mta(self, reporting_mta):
        """Sets the reporting_mta of this WebhookDeliveryStatusPayload.

        Mail Transfer Agent reporting delivery status  # noqa: E501

        :param reporting_mta: The reporting_mta of this WebhookDeliveryStatusPayload.  # noqa: E501
        :type: str
        """

        self._reporting_mta = reporting_mta

    @property
    def recipients(self):
        """Gets the recipients of this WebhookDeliveryStatusPayload.  # noqa: E501

        Recipients for delivery  # noqa: E501

        :return: The recipients of this WebhookDeliveryStatusPayload.  # noqa: E501
        :rtype: list[str]
        """
        return self._recipients

    @recipients.setter
    def recipients(self, recipients):
        """Sets the recipients of this WebhookDeliveryStatusPayload.

        Recipients for delivery  # noqa: E501

        :param recipients: The recipients of this WebhookDeliveryStatusPayload.  # noqa: E501
        :type: list[str]
        """

        self._recipients = recipients

    @property
    def smtp_response(self):
        """Gets the smtp_response of this WebhookDeliveryStatusPayload.  # noqa: E501

        SMTP server response message  # noqa: E501

        :return: The smtp_response of this WebhookDeliveryStatusPayload.  # noqa: E501
        :rtype: str
        """
        return self._smtp_response

    @smtp_response.setter
    def smtp_response(self, smtp_response):
        """Sets the smtp_response of this WebhookDeliveryStatusPayload.

        SMTP server response message  # noqa: E501

        :param smtp_response: The smtp_response of this WebhookDeliveryStatusPayload.  # noqa: E501
        :type: str
        """

        self._smtp_response = smtp_response

    @property
    def smtp_status_code(self):
        """Gets the smtp_status_code of this WebhookDeliveryStatusPayload.  # noqa: E501

        SMTP server status  # noqa: E501

        :return: The smtp_status_code of this WebhookDeliveryStatusPayload.  # noqa: E501
        :rtype: int
        """
        return self._smtp_status_code

    @smtp_status_code.setter
    def smtp_status_code(self, smtp_status_code):
        """Sets the smtp_status_code of this WebhookDeliveryStatusPayload.

        SMTP server status  # noqa: E501

        :param smtp_status_code: The smtp_status_code of this WebhookDeliveryStatusPayload.  # noqa: E501
        :type: int
        """

        self._smtp_status_code = smtp_status_code

    @property
    def processing_time_millis(self):
        """Gets the processing_time_millis of this WebhookDeliveryStatusPayload.  # noqa: E501

        Time in milliseconds for delivery processing  # noqa: E501

        :return: The processing_time_millis of this WebhookDeliveryStatusPayload.  # noqa: E501
        :rtype: int
        """
        return self._processing_time_millis

    @processing_time_millis.setter
    def processing_time_millis(self, processing_time_millis):
        """Sets the processing_time_millis of this WebhookDeliveryStatusPayload.

        Time in milliseconds for delivery processing  # noqa: E501

        :param processing_time_millis: The processing_time_millis of this WebhookDeliveryStatusPayload.  # noqa: E501
        :type: int
        """

        self._processing_time_millis = processing_time_millis

    @property
    def received(self):
        """Gets the received of this WebhookDeliveryStatusPayload.  # noqa: E501

        Time event was received  # noqa: E501

        :return: The received of this WebhookDeliveryStatusPayload.  # noqa: E501
        :rtype: datetime
        """
        return self._received

    @received.setter
    def received(self, received):
        """Sets the received of this WebhookDeliveryStatusPayload.

        Time event was received  # noqa: E501

        :param received: The received of this WebhookDeliveryStatusPayload.  # noqa: E501
        :type: datetime
        """

        self._received = received

    @property
    def subject(self):
        """Gets the subject of this WebhookDeliveryStatusPayload.  # noqa: E501

        Email subject  # noqa: E501

        :return: The subject of this WebhookDeliveryStatusPayload.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this WebhookDeliveryStatusPayload.

        Email subject  # noqa: E501

        :param subject: The subject of this WebhookDeliveryStatusPayload.  # noqa: E501
        :type: str
        """

        self._subject = subject

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookDeliveryStatusPayload):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookDeliveryStatusPayload):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_bounce_recipient_payload.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookBounceRecipientPayload(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'message_id': 'str',
        'webhook_id': 'str',
        'event_name': 'str',
        'webhook_name': 'str',
        'recipient': 'str'
    }

    attribute_map = {
        'message_id': 'messageId',
        'webhook_id': 'webhookId',
        'event_name': 'eventName',
        'webhook_name': 'webhookName',
        'recipient': 'recipient'
    }

    def __init__(self, message_id=None, webhook_id=None, event_name=None, webhook_name=None, recipient=None, local_vars_configuration=None):  # noqa: E501
        """WebhookBounceRecipientPayload - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._message_id = None
        self._webhook_id = None
        self._event_name = None
        self._webhook_name = None
        self._recipient = None
        self.discriminator = None

        self.message_id = message_id
        self.webhook_id = webhook_id
        self.event_name = event_name
        self.webhook_name = webhook_name
        self.recipient = recipient

    @property
    def message_id(self):
        """Gets the message_id of this WebhookBounceRecipientPayload.  # noqa: E501

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :return: The message_id of this WebhookBounceRecipientPayload.  # noqa: E501
        :rtype: str
        """
        return self._message_id

    @message_id.setter
    def message_id(self, message_id):
        """Sets the message_id of this WebhookBounceRecipientPayload.

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :param message_id: The message_id of this WebhookBounceRecipientPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and message_id is None:  # noqa: E501
            raise ValueError("Invalid value for `message_id`, must not be `None`")  # noqa: E501

        self._message_id = message_id

    @property
    def webhook_id(self):
        """Gets the webhook_id of this WebhookBounceRecipientPayload.  # noqa: E501

        ID of webhook entity being triggered  # noqa: E501

        :return: The webhook_id of this WebhookBounceRecipientPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_id

    @webhook_id.setter
    def webhook_id(self, webhook_id):
        """Sets the webhook_id of this WebhookBounceRecipientPayload.

        ID of webhook entity being triggered  # noqa: E501

        :param webhook_id: The webhook_id of this WebhookBounceRecipientPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and webhook_id is None:  # noqa: E501
            raise ValueError("Invalid value for `webhook_id`, must not be `None`")  # noqa: E501

        self._webhook_id = webhook_id

    @property
    def event_name(self):
        """Gets the event_name of this WebhookBounceRecipientPayload.  # noqa: E501

        Name of the event type webhook is being triggered for.  # noqa: E501

        :return: The event_name of this WebhookBounceRecipientPayload.  # noqa: E501
        :rtype: str
        """
        return self._event_name

    @event_name.setter
    def event_name(self, event_name):
        """Sets the event_name of this WebhookBounceRecipientPayload.

        Name of the event type webhook is being triggered for.  # noqa: E501

        :param event_name: The event_name of this WebhookBounceRecipientPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and event_name is None:  # noqa: E501
            raise ValueError("Invalid value for `event_name`, must not be `None`")  # noqa: E501
        allowed_values = ["EMAIL_RECEIVED", "NEW_EMAIL", "NEW_CONTACT", "NEW_ATTACHMENT", "EMAIL_OPENED", "EMAIL_READ", "DELIVERY_STATUS", "BOUNCE", "BOUNCE_RECIPIENT", "NEW_SMS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and event_name not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `event_name` ({0}), must be one of {1}"  # noqa: E501
                .format(event_name, allowed_values)
            )

        self._event_name = event_name

    @property
    def webhook_name(self):
        """Gets the webhook_name of this WebhookBounceRecipientPayload.  # noqa: E501

        Name of the webhook being triggered  # noqa: E501

        :return: The webhook_name of this WebhookBounceRecipientPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_name

    @webhook_name.setter
    def webhook_name(self, webhook_name):
        """Sets the webhook_name of this WebhookBounceRecipientPayload.

        Name of the webhook being triggered  # noqa: E501

        :param webhook_name: The webhook_name of this WebhookBounceRecipientPayload.  # noqa: E501
        :type: str
        """

        self._webhook_name = webhook_name

    @property
    def recipient(self):
        """Gets the recipient of this WebhookBounceRecipientPayload.  # noqa: E501

        Email address that caused a bounce. Make note of the address and try not to message it again to preserve your reputation.  # noqa: E501

        :return: The recipient of this WebhookBounceRecipientPayload.  # noqa: E501
        :rtype: str
        """
        return self._recipient

    @recipient.setter
    def recipient(self, recipient):
        """Sets the recipient of this WebhookBounceRecipientPayload.

        Email address that caused a bounce. Make note of the address and try not to message it again to preserve your reputation.  # noqa: E501

        :param recipient: The recipient of this WebhookBounceRecipientPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and recipient is None:  # noqa: E501
            raise ValueError("Invalid value for `recipient`, must not be `None`")  # noqa: E501

        self._recipient = recipient

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookBounceRecipientPayload):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookBounceRecipientPayload):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/webhook_bounce_payload.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WebhookBouncePayload(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'message_id': 'str',
        'webhook_id': 'str',
        'event_name': 'str',
        'webhook_name': 'str',
        'bounce_id': 'str',
        'sent_to_recipients': 'list[str]',
        'sender': 'str',
        'bounce_recipients': 'list[str]'
    }

    attribute_map = {
        'message_id': 'messageId',
        'webhook_id': 'webhookId',
        'event_name': 'eventName',
        'webhook_name': 'webhookName',
        'bounce_id': 'bounceId',
        'sent_to_recipients': 'sentToRecipients',
        'sender': 'sender',
        'bounce_recipients': 'bounceRecipients'
    }

    def __init__(self, message_id=None, webhook_id=None, event_name=None, webhook_name=None, bounce_id=None, sent_to_recipients=None, sender=None, bounce_recipients=None, local_vars_configuration=None):  # noqa: E501
        """WebhookBouncePayload - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._message_id = None
        self._webhook_id = None
        self._event_name = None
        self._webhook_name = None
        self._bounce_id = None
        self._sent_to_recipients = None
        self._sender = None
        self._bounce_recipients = None
        self.discriminator = None

        self.message_id = message_id
        self.webhook_id = webhook_id
        self.event_name = event_name
        self.webhook_name = webhook_name
        self.bounce_id = bounce_id
        self.sent_to_recipients = sent_to_recipients
        self.sender = sender
        self.bounce_recipients = bounce_recipients

    @property
    def message_id(self):
        """Gets the message_id of this WebhookBouncePayload.  # noqa: E501

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :return: The message_id of this WebhookBouncePayload.  # noqa: E501
        :rtype: str
        """
        return self._message_id

    @message_id.setter
    def message_id(self, message_id):
        """Sets the message_id of this WebhookBouncePayload.

        Idempotent message ID. Store this ID locally or in a database to prevent message duplication.  # noqa: E501

        :param message_id: The message_id of this WebhookBouncePayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and message_id is None:  # noqa: E501
            raise ValueError("Invalid value for `message_id`, must not be `None`")  # noqa: E501

        self._message_id = message_id

    @property
    def webhook_id(self):
        """Gets the webhook_id of this WebhookBouncePayload.  # noqa: E501

        ID of webhook entity being triggered  # noqa: E501

        :return: The webhook_id of this WebhookBouncePayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_id

    @webhook_id.setter
    def webhook_id(self, webhook_id):
        """Sets the webhook_id of this WebhookBouncePayload.

        ID of webhook entity being triggered  # noqa: E501

        :param webhook_id: The webhook_id of this WebhookBouncePayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and webhook_id is None:  # noqa: E501
            raise ValueError("Invalid value for `webhook_id`, must not be `None`")  # noqa: E501

        self._webhook_id = webhook_id

    @property
    def event_name(self):
        """Gets the event_name of this WebhookBouncePayload.  # noqa: E501

        Name of the event type webhook is being triggered for.  # noqa: E501

        :return: The event_name of this WebhookBouncePayload.  # noqa: E501
        :rtype: str
        """
        return self._event_name

    @event_name.setter
    def event_name(self, event_name):
        """Sets the event_name of this WebhookBouncePayload.

        Name of the event type webhook is being triggered for.  # noqa: E501

        :param event_name: The event_name of this WebhookBouncePayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and event_name is None:  # noqa: E501
            raise ValueError("Invalid value for `event_name`, must not be `None`")  # noqa: E501
        allowed_values = ["EMAIL_RECEIVED", "NEW_EMAIL", "NEW_CONTACT", "NEW_ATTACHMENT", "EMAIL_OPENED", "EMAIL_READ", "DELIVERY_STATUS", "BOUNCE", "BOUNCE_RECIPIENT", "NEW_SMS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and event_name not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `event_name` ({0}), must be one of {1}"  # noqa: E501
                .format(event_name, allowed_values)
            )

        self._event_name = event_name

    @property
    def webhook_name(self):
        """Gets the webhook_name of this WebhookBouncePayload.  # noqa: E501

        Name of the webhook being triggered  # noqa: E501

        :return: The webhook_name of this WebhookBouncePayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_name

    @webhook_name.setter
    def webhook_name(self, webhook_name):
        """Sets the webhook_name of this WebhookBouncePayload.

        Name of the webhook being triggered  # noqa: E501

        :param webhook_name: The webhook_name of this WebhookBouncePayload.  # noqa: E501
        :type: str
        """

        self._webhook_name = webhook_name

    @property
    def bounce_id(self):
        """Gets the bounce_id of this WebhookBouncePayload.  # noqa: E501

        ID of the bounce email record. Use the ID with the bounce controller to view more information  # noqa: E501

        :return: The bounce_id of this WebhookBouncePayload.  # noqa: E501
        :rtype: str
        """
        return self._bounce_id

    @bounce_id.setter
    def bounce_id(self, bounce_id):
        """Sets the bounce_id of this WebhookBouncePayload.

        ID of the bounce email record. Use the ID with the bounce controller to view more information  # noqa: E501

        :param bounce_id: The bounce_id of this WebhookBouncePayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and bounce_id is None:  # noqa: E501
            raise ValueError("Invalid value for `bounce_id`, must not be `None`")  # noqa: E501

        self._bounce_id = bounce_id

    @property
    def sent_to_recipients(self):
        """Gets the sent_to_recipients of this WebhookBouncePayload.  # noqa: E501

        Email sent to recipients  # noqa: E501

        :return: The sent_to_recipients of this WebhookBouncePayload.  # noqa: E501
        :rtype: list[str]
        """
        return self._sent_to_recipients

    @sent_to_recipients.setter
    def sent_to_recipients(self, sent_to_recipients):
        """Sets the sent_to_recipients of this WebhookBouncePayload.

        Email sent to recipients  # noqa: E501

        :param sent_to_recipients: The sent_to_recipients of this WebhookBouncePayload.  # noqa: E501
        :type: list[str]
        """

        self._sent_to_recipients = sent_to_recipients

    @property
    def sender(self):
        """Gets the sender of this WebhookBouncePayload.  # noqa: E501

        Sender causing bounce  # noqa: E501

        :return: The sender of this WebhookBouncePayload.  # noqa: E501
        :rtype: str
        """
        return self._sender

    @sender.setter
    def sender(self, sender):
        """Sets the sender of this WebhookBouncePayload.

        Sender causing bounce  # noqa: E501

        :param sender: The sender of this WebhookBouncePayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and sender is None:  # noqa: E501
            raise ValueError("Invalid value for `sender`, must not be `None`")  # noqa: E501

        self._sender = sender

    @property
    def bounce_recipients(self):
        """Gets the bounce_recipients of this WebhookBouncePayload.  # noqa: E501

        Email addresses that resulted in a bounce or email being rejected. Please save these recipients and avoid emailing them in the future to maintain your reputation.  # noqa: E501

        :return: The bounce_recipients of this WebhookBouncePayload.  # noqa: E501
        :rtype: list[str]
        """
        return self._bounce_recipients

    @bounce_recipients.setter
    def bounce_recipients(self, bounce_recipients):
        """Sets the bounce_recipients of this WebhookBouncePayload.

        Email addresses that resulted in a bounce or email being rejected. Please save these recipients and avoid emailing them in the future to maintain your reputation.  # noqa: E501

        :param bounce_recipients: The bounce_recipients of this WebhookBouncePayload.  # noqa: E501
        :type: list[str]
        """

        self._bounce_recipients = bounce_recipients

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WebhookBouncePayload):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WebhookBouncePayload):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/wait_for_sms_conditions.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WaitForSmsConditions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'phone_number_id': 'str',
        'limit': 'int',
        'count': 'int',
        'delay_timeout': 'int',
        'timeout': 'int',
        'unread_only': 'bool',
        'count_type': 'str',
        'matches': 'list[SmsMatchOption]',
        'sort_direction': 'str',
        'since': 'datetime',
        'before': 'datetime'
    }

    attribute_map = {
        'phone_number_id': 'phoneNumberId',
        'limit': 'limit',
        'count': 'count',
        'delay_timeout': 'delayTimeout',
        'timeout': 'timeout',
        'unread_only': 'unreadOnly',
        'count_type': 'countType',
        'matches': 'matches',
        'sort_direction': 'sortDirection',
        'since': 'since',
        'before': 'before'
    }

    def __init__(self, phone_number_id=None, limit=None, count=None, delay_timeout=None, timeout=None, unread_only=None, count_type=None, matches=None, sort_direction=None, since=None, before=None, local_vars_configuration=None):  # noqa: E501
        """WaitForSmsConditions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._phone_number_id = None
        self._limit = None
        self._count = None
        self._delay_timeout = None
        self._timeout = None
        self._unread_only = None
        self._count_type = None
        self._matches = None
        self._sort_direction = None
        self._since = None
        self._before = None
        self.discriminator = None

        self.phone_number_id = phone_number_id
        self.limit = limit
        self.count = count
        self.delay_timeout = delay_timeout
        self.timeout = timeout
        self.unread_only = unread_only
        self.count_type = count_type
        self.matches = matches
        self.sort_direction = sort_direction
        self.since = since
        self.before = before

    @property
    def phone_number_id(self):
        """Gets the phone_number_id of this WaitForSmsConditions.  # noqa: E501

        ID of phone number to search within and apply conditions to. Essentially filtering the SMS found to give a count.  # noqa: E501

        :return: The phone_number_id of this WaitForSmsConditions.  # noqa: E501
        :rtype: str
        """
        return self._phone_number_id

    @phone_number_id.setter
    def phone_number_id(self, phone_number_id):
        """Sets the phone_number_id of this WaitForSmsConditions.

        ID of phone number to search within and apply conditions to. Essentially filtering the SMS found to give a count.  # noqa: E501

        :param phone_number_id: The phone_number_id of this WaitForSmsConditions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and phone_number_id is None:  # noqa: E501
            raise ValueError("Invalid value for `phone_number_id`, must not be `None`")  # noqa: E501

        self._phone_number_id = phone_number_id

    @property
    def limit(self):
        """Gets the limit of this WaitForSmsConditions.  # noqa: E501

        Limit results  # noqa: E501

        :return: The limit of this WaitForSmsConditions.  # noqa: E501
        :rtype: int
        """
        return self._limit

    @limit.setter
    def limit(self, limit):
        """Sets the limit of this WaitForSmsConditions.

        Limit results  # noqa: E501

        :param limit: The limit of this WaitForSmsConditions.  # noqa: E501
        :type: int
        """

        self._limit = limit

    @property
    def count(self):
        """Gets the count of this WaitForSmsConditions.  # noqa: E501

        Number of results that should match conditions. Either exactly or at least this amount based on the `countType`. If count condition is not met and the timeout has not been reached the `waitFor` method will retry the operation.  # noqa: E501

        :return: The count of this WaitForSmsConditions.  # noqa: E501
        :rtype: int
        """
        return self._count

    @count.setter
    def count(self, count):
        """Sets the count of this WaitForSmsConditions.

        Number of results that should match conditions. Either exactly or at least this amount based on the `countType`. If count condition is not met and the timeout has not been reached the `waitFor` method will retry the operation.  # noqa: E501

        :param count: The count of this WaitForSmsConditions.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and count is None:  # noqa: E501
            raise ValueError("Invalid value for `count`, must not be `None`")  # noqa: E501

        self._count = count

    @property
    def delay_timeout(self):
        """Gets the delay_timeout of this WaitForSmsConditions.  # noqa: E501

        Max time in milliseconds to wait between retries if a `timeout` is specified.  # noqa: E501

        :return: The delay_timeout of this WaitForSmsConditions.  # noqa: E501
        :rtype: int
        """
        return self._delay_timeout

    @delay_timeout.setter
    def delay_timeout(self, delay_timeout):
        """Sets the delay_timeout of this WaitForSmsConditions.

        Max time in milliseconds to wait between retries if a `timeout` is specified.  # noqa: E501

        :param delay_timeout: The delay_timeout of this WaitForSmsConditions.  # noqa: E501
        :type: int
        """

        self._delay_timeout = delay_timeout

    @property
    def timeout(self):
        """Gets the timeout of this WaitForSmsConditions.  # noqa: E501

        Max time in milliseconds to retry the `waitFor` operation until conditions are met.  # noqa: E501

        :return: The timeout of this WaitForSmsConditions.  # noqa: E501
        :rtype: int
        """
        return self._timeout

    @timeout.setter
    def timeout(self, timeout):
        """Sets the timeout of this WaitForSmsConditions.

        Max time in milliseconds to retry the `waitFor` operation until conditions are met.  # noqa: E501

        :param timeout: The timeout of this WaitForSmsConditions.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and timeout is None:  # noqa: E501
            raise ValueError("Invalid value for `timeout`, must not be `None`")  # noqa: E501

        self._timeout = timeout

    @property
    def unread_only(self):
        """Gets the unread_only of this WaitForSmsConditions.  # noqa: E501

        Apply conditions only to **unread** SMS. All SMS messages begin with `read=false`. An SMS is marked `read=true` when an `SMS` has been returned to the user at least once. For example you have called `getSms` or `waitForSms` etc., or you have viewed the SMS in the dashboard.  # noqa: E501

        :return: The unread_only of this WaitForSmsConditions.  # noqa: E501
        :rtype: bool
        """
        return self._unread_only

    @unread_only.setter
    def unread_only(self, unread_only):
        """Sets the unread_only of this WaitForSmsConditions.

        Apply conditions only to **unread** SMS. All SMS messages begin with `read=false`. An SMS is marked `read=true` when an `SMS` has been returned to the user at least once. For example you have called `getSms` or `waitForSms` etc., or you have viewed the SMS in the dashboard.  # noqa: E501

        :param unread_only: The unread_only of this WaitForSmsConditions.  # noqa: E501
        :type: bool
        """

        self._unread_only = unread_only

    @property
    def count_type(self):
        """Gets the count_type of this WaitForSmsConditions.  # noqa: E501

        How result size should be compared with the expected size. Exactly or at-least matching result?  # noqa: E501

        :return: The count_type of this WaitForSmsConditions.  # noqa: E501
        :rtype: str
        """
        return self._count_type

    @count_type.setter
    def count_type(self, count_type):
        """Sets the count_type of this WaitForSmsConditions.

        How result size should be compared with the expected size. Exactly or at-least matching result?  # noqa: E501

        :param count_type: The count_type of this WaitForSmsConditions.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"EXACTLY", "ATLEAST"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and count_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `count_type` ({0}), must be one of {1}"  # noqa: E501
                .format(count_type, allowed_values)
            )

        self._count_type = count_type

    @property
    def matches(self):
        """Gets the matches of this WaitForSmsConditions.  # noqa: E501

        Conditions that should be matched for an SMS to qualify for results. Each condition will be applied in order to each SMS within a phone number to filter a result list of matching SMSs you are waiting for.  # noqa: E501

        :return: The matches of this WaitForSmsConditions.  # noqa: E501
        :rtype: list[SmsMatchOption]
        """
        return self._matches

    @matches.setter
    def matches(self, matches):
        """Sets the matches of this WaitForSmsConditions.

        Conditions that should be matched for an SMS to qualify for results. Each condition will be applied in order to each SMS within a phone number to filter a result list of matching SMSs you are waiting for.  # noqa: E501

        :param matches: The matches of this WaitForSmsConditions.  # noqa: E501
        :type: list[SmsMatchOption]
        """

        self._matches = matches

    @property
    def sort_direction(self):
        """Gets the sort_direction of this WaitForSmsConditions.  # noqa: E501

        Direction to sort matching SMSs by created time  # noqa: E501

        :return: The sort_direction of this WaitForSmsConditions.  # noqa: E501
        :rtype: str
        """
        return self._sort_direction

    @sort_direction.setter
    def sort_direction(self, sort_direction):
        """Sets the sort_direction of this WaitForSmsConditions.

        Direction to sort matching SMSs by created time  # noqa: E501

        :param sort_direction: The sort_direction of this WaitForSmsConditions.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"ASC", "DESC"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and sort_direction not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `sort_direction` ({0}), must be one of {1}"  # noqa: E501
                .format(sort_direction, allowed_values)
            )

        self._sort_direction = sort_direction

    @property
    def since(self):
        """Gets the since of this WaitForSmsConditions.  # noqa: E501

        ISO Date Time earliest time of SMS to consider. Filter for matching SMSs that were received after this date  # noqa: E501

        :return: The since of this WaitForSmsConditions.  # noqa: E501
        :rtype: datetime
        """
        return self._since

    @since.setter
    def since(self, since):
        """Sets the since of this WaitForSmsConditions.

        ISO Date Time earliest time of SMS to consider. Filter for matching SMSs that were received after this date  # noqa: E501

        :param since: The since of this WaitForSmsConditions.  # noqa: E501
        :type: datetime
        """

        self._since = since

    @property
    def before(self):
        """Gets the before of this WaitForSmsConditions.  # noqa: E501

        ISO Date Time latest time of SMS to consider. Filter for matching SMSs that were received before this date  # noqa: E501

        :return: The before of this WaitForSmsConditions.  # noqa: E501
        :rtype: datetime
        """
        return self._before

    @before.setter
    def before(self, before):
        """Sets the before of this WaitForSmsConditions.

        ISO Date Time latest time of SMS to consider. Filter for matching SMSs that were received before this date  # noqa: E501

        :param before: The before of this WaitForSmsConditions.  # noqa: E501
        :type: datetime
        """

        self._before = before

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WaitForSmsConditions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WaitForSmsConditions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/wait_for_single_sms_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WaitForSingleSmsOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'phone_number_id': 'str',
        'timeout': 'int',
        'unread_only': 'bool',
        'before': 'datetime',
        'since': 'datetime',
        'sort_direction': 'str',
        'delay': 'int'
    }

    attribute_map = {
        'phone_number_id': 'phoneNumberId',
        'timeout': 'timeout',
        'unread_only': 'unreadOnly',
        'before': 'before',
        'since': 'since',
        'sort_direction': 'sortDirection',
        'delay': 'delay'
    }

    def __init__(self, phone_number_id=None, timeout=None, unread_only=None, before=None, since=None, sort_direction=None, delay=None, local_vars_configuration=None):  # noqa: E501
        """WaitForSingleSmsOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._phone_number_id = None
        self._timeout = None
        self._unread_only = None
        self._before = None
        self._since = None
        self._sort_direction = None
        self._delay = None
        self.discriminator = None

        self.phone_number_id = phone_number_id
        self.timeout = timeout
        if unread_only is not None:
            self.unread_only = unread_only
        if before is not None:
            self.before = before
        if since is not None:
            self.since = since
        if sort_direction is not None:
            self.sort_direction = sort_direction
        if delay is not None:
            self.delay = delay

    @property
    def phone_number_id(self):
        """Gets the phone_number_id of this WaitForSingleSmsOptions.  # noqa: E501


        :return: The phone_number_id of this WaitForSingleSmsOptions.  # noqa: E501
        :rtype: str
        """
        return self._phone_number_id

    @phone_number_id.setter
    def phone_number_id(self, phone_number_id):
        """Sets the phone_number_id of this WaitForSingleSmsOptions.


        :param phone_number_id: The phone_number_id of this WaitForSingleSmsOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and phone_number_id is None:  # noqa: E501
            raise ValueError("Invalid value for `phone_number_id`, must not be `None`")  # noqa: E501

        self._phone_number_id = phone_number_id

    @property
    def timeout(self):
        """Gets the timeout of this WaitForSingleSmsOptions.  # noqa: E501


        :return: The timeout of this WaitForSingleSmsOptions.  # noqa: E501
        :rtype: int
        """
        return self._timeout

    @timeout.setter
    def timeout(self, timeout):
        """Sets the timeout of this WaitForSingleSmsOptions.


        :param timeout: The timeout of this WaitForSingleSmsOptions.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and timeout is None:  # noqa: E501
            raise ValueError("Invalid value for `timeout`, must not be `None`")  # noqa: E501

        self._timeout = timeout

    @property
    def unread_only(self):
        """Gets the unread_only of this WaitForSingleSmsOptions.  # noqa: E501


        :return: The unread_only of this WaitForSingleSmsOptions.  # noqa: E501
        :rtype: bool
        """
        return self._unread_only

    @unread_only.setter
    def unread_only(self, unread_only):
        """Sets the unread_only of this WaitForSingleSmsOptions.


        :param unread_only: The unread_only of this WaitForSingleSmsOptions.  # noqa: E501
        :type: bool
        """

        self._unread_only = unread_only

    @property
    def before(self):
        """Gets the before of this WaitForSingleSmsOptions.  # noqa: E501


        :return: The before of this WaitForSingleSmsOptions.  # noqa: E501
        :rtype: datetime
        """
        return self._before

    @before.setter
    def before(self, before):
        """Sets the before of this WaitForSingleSmsOptions.


        :param before: The before of this WaitForSingleSmsOptions.  # noqa: E501
        :type: datetime
        """

        self._before = before

    @property
    def since(self):
        """Gets the since of this WaitForSingleSmsOptions.  # noqa: E501


        :return: The since of this WaitForSingleSmsOptions.  # noqa: E501
        :rtype: datetime
        """
        return self._since

    @since.setter
    def since(self, since):
        """Sets the since of this WaitForSingleSmsOptions.


        :param since: The since of this WaitForSingleSmsOptions.  # noqa: E501
        :type: datetime
        """

        self._since = since

    @property
    def sort_direction(self):
        """Gets the sort_direction of this WaitForSingleSmsOptions.  # noqa: E501


        :return: The sort_direction of this WaitForSingleSmsOptions.  # noqa: E501
        :rtype: str
        """
        return self._sort_direction

    @sort_direction.setter
    def sort_direction(self, sort_direction):
        """Sets the sort_direction of this WaitForSingleSmsOptions.


        :param sort_direction: The sort_direction of this WaitForSingleSmsOptions.  # noqa: E501
        :type: str
        """
        allowed_values = ["ASC", "DESC"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and sort_direction not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `sort_direction` ({0}), must be one of {1}"  # noqa: E501
                .format(sort_direction, allowed_values)
            )

        self._sort_direction = sort_direction

    @property
    def delay(self):
        """Gets the delay of this WaitForSingleSmsOptions.  # noqa: E501


        :return: The delay of this WaitForSingleSmsOptions.  # noqa: E501
        :rtype: int
        """
        return self._delay

    @delay.setter
    def delay(self, delay):
        """Sets the delay of this WaitForSingleSmsOptions.


        :param delay: The delay of this WaitForSingleSmsOptions.  # noqa: E501
        :type: int
        """

        self._delay = delay

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WaitForSingleSmsOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WaitForSingleSmsOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/wait_for_conditions.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class WaitForConditions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'inbox_id': 'str',
        'count': 'int',
        'delay_timeout': 'int',
        'timeout': 'int',
        'unread_only': 'bool',
        'count_type': 'str',
        'matches': 'list[MatchOption]',
        'sort_direction': 'str',
        'since': 'datetime',
        'before': 'datetime'
    }

    attribute_map = {
        'inbox_id': 'inboxId',
        'count': 'count',
        'delay_timeout': 'delayTimeout',
        'timeout': 'timeout',
        'unread_only': 'unreadOnly',
        'count_type': 'countType',
        'matches': 'matches',
        'sort_direction': 'sortDirection',
        'since': 'since',
        'before': 'before'
    }

    def __init__(self, inbox_id=None, count=None, delay_timeout=None, timeout=None, unread_only=None, count_type=None, matches=None, sort_direction=None, since=None, before=None, local_vars_configuration=None):  # noqa: E501
        """WaitForConditions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._inbox_id = None
        self._count = None
        self._delay_timeout = None
        self._timeout = None
        self._unread_only = None
        self._count_type = None
        self._matches = None
        self._sort_direction = None
        self._since = None
        self._before = None
        self.discriminator = None

        self.inbox_id = inbox_id
        self.count = count
        self.delay_timeout = delay_timeout
        self.timeout = timeout
        self.unread_only = unread_only
        self.count_type = count_type
        self.matches = matches
        self.sort_direction = sort_direction
        self.since = since
        self.before = before

    @property
    def inbox_id(self):
        """Gets the inbox_id of this WaitForConditions.  # noqa: E501

        ID of inbox to search within and apply conditions to. Essentially filtering the emails found to give a count.  # noqa: E501

        :return: The inbox_id of this WaitForConditions.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this WaitForConditions.

        ID of inbox to search within and apply conditions to. Essentially filtering the emails found to give a count.  # noqa: E501

        :param inbox_id: The inbox_id of this WaitForConditions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def count(self):
        """Gets the count of this WaitForConditions.  # noqa: E501

        Number of results that should match conditions. Either exactly or at least this amount based on the `countType`. If count condition is not met and the timeout has not been reached the `waitFor` method will retry the operation.  # noqa: E501

        :return: The count of this WaitForConditions.  # noqa: E501
        :rtype: int
        """
        return self._count

    @count.setter
    def count(self, count):
        """Sets the count of this WaitForConditions.

        Number of results that should match conditions. Either exactly or at least this amount based on the `countType`. If count condition is not met and the timeout has not been reached the `waitFor` method will retry the operation.  # noqa: E501

        :param count: The count of this WaitForConditions.  # noqa: E501
        :type: int
        """

        self._count = count

    @property
    def delay_timeout(self):
        """Gets the delay_timeout of this WaitForConditions.  # noqa: E501

        Max time in milliseconds to wait between retries if a `timeout` is specified.  # noqa: E501

        :return: The delay_timeout of this WaitForConditions.  # noqa: E501
        :rtype: int
        """
        return self._delay_timeout

    @delay_timeout.setter
    def delay_timeout(self, delay_timeout):
        """Sets the delay_timeout of this WaitForConditions.

        Max time in milliseconds to wait between retries if a `timeout` is specified.  # noqa: E501

        :param delay_timeout: The delay_timeout of this WaitForConditions.  # noqa: E501
        :type: int
        """

        self._delay_timeout = delay_timeout

    @property
    def timeout(self):
        """Gets the timeout of this WaitForConditions.  # noqa: E501

        Max time in milliseconds to retry the `waitFor` operation until conditions are met.  # noqa: E501

        :return: The timeout of this WaitForConditions.  # noqa: E501
        :rtype: int
        """
        return self._timeout

    @timeout.setter
    def timeout(self, timeout):
        """Sets the timeout of this WaitForConditions.

        Max time in milliseconds to retry the `waitFor` operation until conditions are met.  # noqa: E501

        :param timeout: The timeout of this WaitForConditions.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and timeout is None:  # noqa: E501
            raise ValueError("Invalid value for `timeout`, must not be `None`")  # noqa: E501

        self._timeout = timeout

    @property
    def unread_only(self):
        """Gets the unread_only of this WaitForConditions.  # noqa: E501

        Apply conditions only to **unread** emails. All emails begin with `read=false`. An email is marked `read=true` when an `EmailDto` representation of it has been returned to the user at least once. For example you have called `getEmail` or `waitForLatestEmail` etc., or you have viewed the email in the dashboard.  # noqa: E501

        :return: The unread_only of this WaitForConditions.  # noqa: E501
        :rtype: bool
        """
        return self._unread_only

    @unread_only.setter
    def unread_only(self, unread_only):
        """Sets the unread_only of this WaitForConditions.

        Apply conditions only to **unread** emails. All emails begin with `read=false`. An email is marked `read=true` when an `EmailDto` representation of it has been returned to the user at least once. For example you have called `getEmail` or `waitForLatestEmail` etc., or you have viewed the email in the dashboard.  # noqa: E501

        :param unread_only: The unread_only of this WaitForConditions.  # noqa: E501
        :type: bool
        """

        self._unread_only = unread_only

    @property
    def count_type(self):
        """Gets the count_type of this WaitForConditions.  # noqa: E501

        How result size should be compared with the expected size. Exactly or at-least matching result?  # noqa: E501

        :return: The count_type of this WaitForConditions.  # noqa: E501
        :rtype: str
        """
        return self._count_type

    @count_type.setter
    def count_type(self, count_type):
        """Sets the count_type of this WaitForConditions.

        How result size should be compared with the expected size. Exactly or at-least matching result?  # noqa: E501

        :param count_type: The count_type of this WaitForConditions.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"EXACTLY", "ATLEAST"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and count_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `count_type` ({0}), must be one of {1}"  # noqa: E501
                .format(count_type, allowed_values)
            )

        self._count_type = count_type

    @property
    def matches(self):
        """Gets the matches of this WaitForConditions.  # noqa: E501

        Conditions that should be matched for an email to qualify for results. Each condition will be applied in order to each email within an inbox to filter a result list of matching emails you are waiting for.  # noqa: E501

        :return: The matches of this WaitForConditions.  # noqa: E501
        :rtype: list[MatchOption]
        """
        return self._matches

    @matches.setter
    def matches(self, matches):
        """Sets the matches of this WaitForConditions.

        Conditions that should be matched for an email to qualify for results. Each condition will be applied in order to each email within an inbox to filter a result list of matching emails you are waiting for.  # noqa: E501

        :param matches: The matches of this WaitForConditions.  # noqa: E501
        :type: list[MatchOption]
        """

        self._matches = matches

    @property
    def sort_direction(self):
        """Gets the sort_direction of this WaitForConditions.  # noqa: E501

        Direction to sort matching emails by created time  # noqa: E501

        :return: The sort_direction of this WaitForConditions.  # noqa: E501
        :rtype: str
        """
        return self._sort_direction

    @sort_direction.setter
    def sort_direction(self, sort_direction):
        """Sets the sort_direction of this WaitForConditions.

        Direction to sort matching emails by created time  # noqa: E501

        :param sort_direction: The sort_direction of this WaitForConditions.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"ASC", "DESC"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and sort_direction not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `sort_direction` ({0}), must be one of {1}"  # noqa: E501
                .format(sort_direction, allowed_values)
            )

        self._sort_direction = sort_direction

    @property
    def since(self):
        """Gets the since of this WaitForConditions.  # noqa: E501

        ISO Date Time earliest time of email to consider. Filter for matching emails that were received after this date  # noqa: E501

        :return: The since of this WaitForConditions.  # noqa: E501
        :rtype: datetime
        """
        return self._since

    @since.setter
    def since(self, since):
        """Sets the since of this WaitForConditions.

        ISO Date Time earliest time of email to consider. Filter for matching emails that were received after this date  # noqa: E501

        :param since: The since of this WaitForConditions.  # noqa: E501
        :type: datetime
        """

        self._since = since

    @property
    def before(self):
        """Gets the before of this WaitForConditions.  # noqa: E501

        ISO Date Time latest time of email to consider. Filter for matching emails that were received before this date  # noqa: E501

        :return: The before of this WaitForConditions.  # noqa: E501
        :rtype: datetime
        """
        return self._before

    @before.setter
    def before(self, before):
        """Sets the before of this WaitForConditions.

        ISO Date Time latest time of email to consider. Filter for matching emails that were received before this date  # noqa: E501

        :param before: The before of this WaitForConditions.  # noqa: E501
        :type: datetime
        """

        self._before = before

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, WaitForConditions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, WaitForConditions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/verify_webhook_signature_results.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class VerifyWebhookSignatureResults(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'is_valid': 'bool'
    }

    attribute_map = {
        'is_valid': 'isValid'
    }

    def __init__(self, is_valid=None, local_vars_configuration=None):  # noqa: E501
        """VerifyWebhookSignatureResults - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._is_valid = None
        self.discriminator = None

        self.is_valid = is_valid

    @property
    def is_valid(self):
        """Gets the is_valid of this VerifyWebhookSignatureResults.  # noqa: E501


        :return: The is_valid of this VerifyWebhookSignatureResults.  # noqa: E501
        :rtype: bool
        """
        return self._is_valid

    @is_valid.setter
    def is_valid(self, is_valid):
        """Sets the is_valid of this VerifyWebhookSignatureResults.


        :param is_valid: The is_valid of this VerifyWebhookSignatureResults.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and is_valid is None:  # noqa: E501
            raise ValueError("Invalid value for `is_valid`, must not be `None`")  # noqa: E501

        self._is_valid = is_valid

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, VerifyWebhookSignatureResults):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, VerifyWebhookSignatureResults):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/verify_webhook_signature_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class VerifyWebhookSignatureOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'message_id': 'str',
        'signature': 'str'
    }

    attribute_map = {
        'message_id': 'messageId',
        'signature': 'signature'
    }

    def __init__(self, message_id=None, signature=None, local_vars_configuration=None):  # noqa: E501
        """VerifyWebhookSignatureOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._message_id = None
        self._signature = None
        self.discriminator = None

        self.message_id = message_id
        self.signature = signature

    @property
    def message_id(self):
        """Gets the message_id of this VerifyWebhookSignatureOptions.  # noqa: E501


        :return: The message_id of this VerifyWebhookSignatureOptions.  # noqa: E501
        :rtype: str
        """
        return self._message_id

    @message_id.setter
    def message_id(self, message_id):
        """Sets the message_id of this VerifyWebhookSignatureOptions.


        :param message_id: The message_id of this VerifyWebhookSignatureOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and message_id is None:  # noqa: E501
            raise ValueError("Invalid value for `message_id`, must not be `None`")  # noqa: E501

        self._message_id = message_id

    @property
    def signature(self):
        """Gets the signature of this VerifyWebhookSignatureOptions.  # noqa: E501


        :return: The signature of this VerifyWebhookSignatureOptions.  # noqa: E501
        :rtype: str
        """
        return self._signature

    @signature.setter
    def signature(self, signature):
        """Sets the signature of this VerifyWebhookSignatureOptions.


        :param signature: The signature of this VerifyWebhookSignatureOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and signature is None:  # noqa: E501
            raise ValueError("Invalid value for `signature`, must not be `None`")  # noqa: E501

        self._signature = signature

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, VerifyWebhookSignatureOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, VerifyWebhookSignatureOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/verify_email_address_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class VerifyEmailAddressOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'mail_server_domain': 'str',
        'email_address': 'str',
        'sender_email_address': 'str',
        'port': 'int'
    }

    attribute_map = {
        'mail_server_domain': 'mailServerDomain',
        'email_address': 'emailAddress',
        'sender_email_address': 'senderEmailAddress',
        'port': 'port'
    }

    def __init__(self, mail_server_domain=None, email_address=None, sender_email_address=None, port=None, local_vars_configuration=None):  # noqa: E501
        """VerifyEmailAddressOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._mail_server_domain = None
        self._email_address = None
        self._sender_email_address = None
        self._port = None
        self.discriminator = None

        self.mail_server_domain = mail_server_domain
        self.email_address = email_address
        self.sender_email_address = sender_email_address
        self.port = port

    @property
    def mail_server_domain(self):
        """Gets the mail_server_domain of this VerifyEmailAddressOptions.  # noqa: E501


        :return: The mail_server_domain of this VerifyEmailAddressOptions.  # noqa: E501
        :rtype: str
        """
        return self._mail_server_domain

    @mail_server_domain.setter
    def mail_server_domain(self, mail_server_domain):
        """Sets the mail_server_domain of this VerifyEmailAddressOptions.


        :param mail_server_domain: The mail_server_domain of this VerifyEmailAddressOptions.  # noqa: E501
        :type: str
        """

        self._mail_server_domain = mail_server_domain

    @property
    def email_address(self):
        """Gets the email_address of this VerifyEmailAddressOptions.  # noqa: E501


        :return: The email_address of this VerifyEmailAddressOptions.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this VerifyEmailAddressOptions.


        :param email_address: The email_address of this VerifyEmailAddressOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    @property
    def sender_email_address(self):
        """Gets the sender_email_address of this VerifyEmailAddressOptions.  # noqa: E501


        :return: The sender_email_address of this VerifyEmailAddressOptions.  # noqa: E501
        :rtype: str
        """
        return self._sender_email_address

    @sender_email_address.setter
    def sender_email_address(self, sender_email_address):
        """Sets the sender_email_address of this VerifyEmailAddressOptions.


        :param sender_email_address: The sender_email_address of this VerifyEmailAddressOptions.  # noqa: E501
        :type: str
        """

        self._sender_email_address = sender_email_address

    @property
    def port(self):
        """Gets the port of this VerifyEmailAddressOptions.  # noqa: E501


        :return: The port of this VerifyEmailAddressOptions.  # noqa: E501
        :rtype: int
        """
        return self._port

    @port.setter
    def port(self, port):
        """Sets the port of this VerifyEmailAddressOptions.


        :param port: The port of this VerifyEmailAddressOptions.  # noqa: E501
        :type: int
        """

        self._port = port

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, VerifyEmailAddressOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, VerifyEmailAddressOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/validation_message.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ValidationMessage(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'line_number': 'int',
        'message': 'str'
    }

    attribute_map = {
        'line_number': 'lineNumber',
        'message': 'message'
    }

    def __init__(self, line_number=None, message=None, local_vars_configuration=None):  # noqa: E501
        """ValidationMessage - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._line_number = None
        self._message = None
        self.discriminator = None

        self.line_number = line_number
        if message is not None:
            self.message = message

    @property
    def line_number(self):
        """Gets the line_number of this ValidationMessage.  # noqa: E501


        :return: The line_number of this ValidationMessage.  # noqa: E501
        :rtype: int
        """
        return self._line_number

    @line_number.setter
    def line_number(self, line_number):
        """Sets the line_number of this ValidationMessage.


        :param line_number: The line_number of this ValidationMessage.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and line_number is None:  # noqa: E501
            raise ValueError("Invalid value for `line_number`, must not be `None`")  # noqa: E501

        self._line_number = line_number

    @property
    def message(self):
        """Gets the message of this ValidationMessage.  # noqa: E501


        :return: The message of this ValidationMessage.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this ValidationMessage.


        :param message: The message of this ValidationMessage.  # noqa: E501
        :type: str
        """

        self._message = message

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ValidationMessage):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ValidationMessage):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/validation_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ValidationDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'email_id': 'str',
        'html': 'HTMLValidationResult'
    }

    attribute_map = {
        'email_id': 'emailId',
        'html': 'html'
    }

    def __init__(self, email_id=None, html=None, local_vars_configuration=None):  # noqa: E501
        """ValidationDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._email_id = None
        self._html = None
        self.discriminator = None

        self.email_id = email_id
        self.html = html

    @property
    def email_id(self):
        """Gets the email_id of this ValidationDto.  # noqa: E501

        ID of the email validated  # noqa: E501

        :return: The email_id of this ValidationDto.  # noqa: E501
        :rtype: str
        """
        return self._email_id

    @email_id.setter
    def email_id(self, email_id):
        """Sets the email_id of this ValidationDto.

        ID of the email validated  # noqa: E501

        :param email_id: The email_id of this ValidationDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_id is None:  # noqa: E501
            raise ValueError("Invalid value for `email_id`, must not be `None`")  # noqa: E501

        self._email_id = email_id

    @property
    def html(self):
        """Gets the html of this ValidationDto.  # noqa: E501


        :return: The html of this ValidationDto.  # noqa: E501
        :rtype: HTMLValidationResult
        """
        return self._html

    @html.setter
    def html(self, html):
        """Sets the html of this ValidationDto.


        :param html: The html of this ValidationDto.  # noqa: E501
        :type: HTMLValidationResult
        """
        if self.local_vars_configuration.client_side_validation and html is None:  # noqa: E501
            raise ValueError("Invalid value for `html`, must not be `None`")  # noqa: E501

        self._html = html

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ValidationDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ValidationDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/validate_email_address_list_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ValidateEmailAddressListResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'valid_email_addresses': 'list[str]',
        'invalid_email_addresses': 'list[str]',
        'result_map_email_address_is_valid': 'dict(str, bool)'
    }

    attribute_map = {
        'valid_email_addresses': 'validEmailAddresses',
        'invalid_email_addresses': 'invalidEmailAddresses',
        'result_map_email_address_is_valid': 'resultMapEmailAddressIsValid'
    }

    def __init__(self, valid_email_addresses=None, invalid_email_addresses=None, result_map_email_address_is_valid=None, local_vars_configuration=None):  # noqa: E501
        """ValidateEmailAddressListResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._valid_email_addresses = None
        self._invalid_email_addresses = None
        self._result_map_email_address_is_valid = None
        self.discriminator = None

        self.valid_email_addresses = valid_email_addresses
        self.invalid_email_addresses = invalid_email_addresses
        self.result_map_email_address_is_valid = result_map_email_address_is_valid

    @property
    def valid_email_addresses(self):
        """Gets the valid_email_addresses of this ValidateEmailAddressListResult.  # noqa: E501


        :return: The valid_email_addresses of this ValidateEmailAddressListResult.  # noqa: E501
        :rtype: list[str]
        """
        return self._valid_email_addresses

    @valid_email_addresses.setter
    def valid_email_addresses(self, valid_email_addresses):
        """Sets the valid_email_addresses of this ValidateEmailAddressListResult.


        :param valid_email_addresses: The valid_email_addresses of this ValidateEmailAddressListResult.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and valid_email_addresses is None:  # noqa: E501
            raise ValueError("Invalid value for `valid_email_addresses`, must not be `None`")  # noqa: E501

        self._valid_email_addresses = valid_email_addresses

    @property
    def invalid_email_addresses(self):
        """Gets the invalid_email_addresses of this ValidateEmailAddressListResult.  # noqa: E501


        :return: The invalid_email_addresses of this ValidateEmailAddressListResult.  # noqa: E501
        :rtype: list[str]
        """
        return self._invalid_email_addresses

    @invalid_email_addresses.setter
    def invalid_email_addresses(self, invalid_email_addresses):
        """Sets the invalid_email_addresses of this ValidateEmailAddressListResult.


        :param invalid_email_addresses: The invalid_email_addresses of this ValidateEmailAddressListResult.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and invalid_email_addresses is None:  # noqa: E501
            raise ValueError("Invalid value for `invalid_email_addresses`, must not be `None`")  # noqa: E501

        self._invalid_email_addresses = invalid_email_addresses

    @property
    def result_map_email_address_is_valid(self):
        """Gets the result_map_email_address_is_valid of this ValidateEmailAddressListResult.  # noqa: E501


        :return: The result_map_email_address_is_valid of this ValidateEmailAddressListResult.  # noqa: E501
        :rtype: dict(str, bool)
        """
        return self._result_map_email_address_is_valid

    @result_map_email_address_is_valid.setter
    def result_map_email_address_is_valid(self, result_map_email_address_is_valid):
        """Sets the result_map_email_address_is_valid of this ValidateEmailAddressListResult.


        :param result_map_email_address_is_valid: The result_map_email_address_is_valid of this ValidateEmailAddressListResult.  # noqa: E501
        :type: dict(str, bool)
        """
        if self.local_vars_configuration.client_side_validation and result_map_email_address_is_valid is None:  # noqa: E501
            raise ValueError("Invalid value for `result_map_email_address_is_valid`, must not be `None`")  # noqa: E501

        self._result_map_email_address_is_valid = result_map_email_address_is_valid

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ValidateEmailAddressListResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ValidateEmailAddressListResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/validate_email_address_list_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ValidateEmailAddressListOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'email_address_list': 'list[str]',
        'ignore_old_results': 'bool'
    }

    attribute_map = {
        'email_address_list': 'emailAddressList',
        'ignore_old_results': 'ignoreOldResults'
    }

    def __init__(self, email_address_list=None, ignore_old_results=None, local_vars_configuration=None):  # noqa: E501
        """ValidateEmailAddressListOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._email_address_list = None
        self._ignore_old_results = None
        self.discriminator = None

        self.email_address_list = email_address_list
        self.ignore_old_results = ignore_old_results

    @property
    def email_address_list(self):
        """Gets the email_address_list of this ValidateEmailAddressListOptions.  # noqa: E501


        :return: The email_address_list of this ValidateEmailAddressListOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._email_address_list

    @email_address_list.setter
    def email_address_list(self, email_address_list):
        """Sets the email_address_list of this ValidateEmailAddressListOptions.


        :param email_address_list: The email_address_list of this ValidateEmailAddressListOptions.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and email_address_list is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address_list`, must not be `None`")  # noqa: E501

        self._email_address_list = email_address_list

    @property
    def ignore_old_results(self):
        """Gets the ignore_old_results of this ValidateEmailAddressListOptions.  # noqa: E501


        :return: The ignore_old_results of this ValidateEmailAddressListOptions.  # noqa: E501
        :rtype: bool
        """
        return self._ignore_old_results

    @ignore_old_results.setter
    def ignore_old_results(self, ignore_old_results):
        """Sets the ignore_old_results of this ValidateEmailAddressListOptions.


        :param ignore_old_results: The ignore_old_results of this ValidateEmailAddressListOptions.  # noqa: E501
        :type: bool
        """

        self._ignore_old_results = ignore_old_results

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ValidateEmailAddressListOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ValidateEmailAddressListOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/user_info_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class UserInfoDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'email_address': 'str',
        'account_state': 'str',
        'subscription_type': 'str',
        'account_type': 'str',
        'created_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'email_address': 'emailAddress',
        'account_state': 'accountState',
        'subscription_type': 'subscriptionType',
        'account_type': 'accountType',
        'created_at': 'createdAt'
    }

    def __init__(self, id=None, email_address=None, account_state=None, subscription_type=None, account_type=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """UserInfoDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._email_address = None
        self._account_state = None
        self._subscription_type = None
        self._account_type = None
        self._created_at = None
        self.discriminator = None

        self.id = id
        self.email_address = email_address
        self.account_state = account_state
        if subscription_type is not None:
            self.subscription_type = subscription_type
        self.account_type = account_type
        self.created_at = created_at

    @property
    def id(self):
        """Gets the id of this UserInfoDto.  # noqa: E501


        :return: The id of this UserInfoDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this UserInfoDto.


        :param id: The id of this UserInfoDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def email_address(self):
        """Gets the email_address of this UserInfoDto.  # noqa: E501


        :return: The email_address of this UserInfoDto.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this UserInfoDto.


        :param email_address: The email_address of this UserInfoDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    @property
    def account_state(self):
        """Gets the account_state of this UserInfoDto.  # noqa: E501


        :return: The account_state of this UserInfoDto.  # noqa: E501
        :rtype: str
        """
        return self._account_state

    @account_state.setter
    def account_state(self, account_state):
        """Sets the account_state of this UserInfoDto.


        :param account_state: The account_state of this UserInfoDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and account_state is None:  # noqa: E501
            raise ValueError("Invalid value for `account_state`, must not be `None`")  # noqa: E501
        allowed_values = ["FROZEN", "ACTIVE"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and account_state not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `account_state` ({0}), must be one of {1}"  # noqa: E501
                .format(account_state, allowed_values)
            )

        self._account_state = account_state

    @property
    def subscription_type(self):
        """Gets the subscription_type of this UserInfoDto.  # noqa: E501


        :return: The subscription_type of this UserInfoDto.  # noqa: E501
        :rtype: str
        """
        return self._subscription_type

    @subscription_type.setter
    def subscription_type(self, subscription_type):
        """Sets the subscription_type of this UserInfoDto.


        :param subscription_type: The subscription_type of this UserInfoDto.  # noqa: E501
        :type: str
        """
        allowed_values = ["PRO_MONTHLY", "STARTER", "PRO", "TEAM", "ENTERPRISE"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and subscription_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `subscription_type` ({0}), must be one of {1}"  # noqa: E501
                .format(subscription_type, allowed_values)
            )

        self._subscription_type = subscription_type

    @property
    def account_type(self):
        """Gets the account_type of this UserInfoDto.  # noqa: E501


        :return: The account_type of this UserInfoDto.  # noqa: E501
        :rtype: str
        """
        return self._account_type

    @account_type.setter
    def account_type(self, account_type):
        """Sets the account_type of this UserInfoDto.


        :param account_type: The account_type of this UserInfoDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and account_type is None:  # noqa: E501
            raise ValueError("Invalid value for `account_type`, must not be `None`")  # noqa: E501
        allowed_values = ["SOLO", "CHILD_SOLO", "CHILD_TEAM", "CHILD_ADMIN"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and account_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `account_type` ({0}), must be one of {1}"  # noqa: E501
                .format(account_type, allowed_values)
            )

        self._account_type = account_type

    @property
    def created_at(self):
        """Gets the created_at of this UserInfoDto.  # noqa: E501


        :return: The created_at of this UserInfoDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this UserInfoDto.


        :param created_at: The created_at of this UserInfoDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, UserInfoDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, UserInfoDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/upload_attachment_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class UploadAttachmentOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content_id': 'str',
        'content_type': 'str',
        'filename': 'str',
        'base64_contents': 'str'
    }

    attribute_map = {
        'content_id': 'contentId',
        'content_type': 'contentType',
        'filename': 'filename',
        'base64_contents': 'base64Contents'
    }

    def __init__(self, content_id=None, content_type=None, filename=None, base64_contents=None, local_vars_configuration=None):  # noqa: E501
        """UploadAttachmentOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content_id = None
        self._content_type = None
        self._filename = None
        self._base64_contents = None
        self.discriminator = None

        self.content_id = content_id
        self.content_type = content_type
        self.filename = filename
        self.base64_contents = base64_contents

    @property
    def content_id(self):
        """Gets the content_id of this UploadAttachmentOptions.  # noqa: E501

        Optional contentId for file.  # noqa: E501

        :return: The content_id of this UploadAttachmentOptions.  # noqa: E501
        :rtype: str
        """
        return self._content_id

    @content_id.setter
    def content_id(self, content_id):
        """Sets the content_id of this UploadAttachmentOptions.

        Optional contentId for file.  # noqa: E501

        :param content_id: The content_id of this UploadAttachmentOptions.  # noqa: E501
        :type: str
        """

        self._content_id = content_id

    @property
    def content_type(self):
        """Gets the content_type of this UploadAttachmentOptions.  # noqa: E501

        Optional contentType for file. For instance `application/pdf`  # noqa: E501

        :return: The content_type of this UploadAttachmentOptions.  # noqa: E501
        :rtype: str
        """
        return self._content_type

    @content_type.setter
    def content_type(self, content_type):
        """Sets the content_type of this UploadAttachmentOptions.

        Optional contentType for file. For instance `application/pdf`  # noqa: E501

        :param content_type: The content_type of this UploadAttachmentOptions.  # noqa: E501
        :type: str
        """

        self._content_type = content_type

    @property
    def filename(self):
        """Gets the filename of this UploadAttachmentOptions.  # noqa: E501

        Optional filename to save upload with. Will be the name that is shown in email clients  # noqa: E501

        :return: The filename of this UploadAttachmentOptions.  # noqa: E501
        :rtype: str
        """
        return self._filename

    @filename.setter
    def filename(self, filename):
        """Sets the filename of this UploadAttachmentOptions.

        Optional filename to save upload with. Will be the name that is shown in email clients  # noqa: E501

        :param filename: The filename of this UploadAttachmentOptions.  # noqa: E501
        :type: str
        """

        self._filename = filename

    @property
    def base64_contents(self):
        """Gets the base64_contents of this UploadAttachmentOptions.  # noqa: E501

        Base64 encoded string of file contents. Typically this means reading the bytes or string content of a file and then converting that to a base64 encoded string. For examples of how to do this see https://www.mailslurp.com/guides/base64-file-uploads/  # noqa: E501

        :return: The base64_contents of this UploadAttachmentOptions.  # noqa: E501
        :rtype: str
        """
        return self._base64_contents

    @base64_contents.setter
    def base64_contents(self, base64_contents):
        """Sets the base64_contents of this UploadAttachmentOptions.

        Base64 encoded string of file contents. Typically this means reading the bytes or string content of a file and then converting that to a base64 encoded string. For examples of how to do this see https://www.mailslurp.com/guides/base64-file-uploads/  # noqa: E501

        :param base64_contents: The base64_contents of this UploadAttachmentOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and base64_contents is None:  # noqa: E501
            raise ValueError("Invalid value for `base64_contents`, must not be `None`")  # noqa: E501

        self._base64_contents = base64_contents

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, UploadAttachmentOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, UploadAttachmentOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/update_smtp_access_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class UpdateSmtpAccessOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'smtp_username': 'str',
        'smtp_password': 'str'
    }

    attribute_map = {
        'smtp_username': 'smtpUsername',
        'smtp_password': 'smtpPassword'
    }

    def __init__(self, smtp_username=None, smtp_password=None, local_vars_configuration=None):  # noqa: E501
        """UpdateSmtpAccessOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._smtp_username = None
        self._smtp_password = None
        self.discriminator = None

        self.smtp_username = smtp_username
        self.smtp_password = smtp_password

    @property
    def smtp_username(self):
        """Gets the smtp_username of this UpdateSmtpAccessOptions.  # noqa: E501

        SMTP username for login  # noqa: E501

        :return: The smtp_username of this UpdateSmtpAccessOptions.  # noqa: E501
        :rtype: str
        """
        return self._smtp_username

    @smtp_username.setter
    def smtp_username(self, smtp_username):
        """Sets the smtp_username of this UpdateSmtpAccessOptions.

        SMTP username for login  # noqa: E501

        :param smtp_username: The smtp_username of this UpdateSmtpAccessOptions.  # noqa: E501
        :type: str
        """

        self._smtp_username = smtp_username

    @property
    def smtp_password(self):
        """Gets the smtp_password of this UpdateSmtpAccessOptions.  # noqa: E501

        SMTP password for login  # noqa: E501

        :return: The smtp_password of this UpdateSmtpAccessOptions.  # noqa: E501
        :rtype: str
        """
        return self._smtp_password

    @smtp_password.setter
    def smtp_password(self, smtp_password):
        """Sets the smtp_password of this UpdateSmtpAccessOptions.

        SMTP password for login  # noqa: E501

        :param smtp_password: The smtp_password of this UpdateSmtpAccessOptions.  # noqa: E501
        :type: str
        """

        self._smtp_password = smtp_password

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, UpdateSmtpAccessOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, UpdateSmtpAccessOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/update_inbox_replier_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class UpdateInboxReplierOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'inbox_id': 'str',
        'name': 'str',
        'field': 'str',
        'match': 'str',
        'reply_to': 'str',
        'subject': 'str',
        '_from': 'str',
        'charset': 'str',
        'is_html': 'bool',
        'ignore_reply_to': 'bool',
        'body': 'str',
        'template_id': 'str',
        'template_variables': 'dict(str, object)'
    }

    attribute_map = {
        'inbox_id': 'inboxId',
        'name': 'name',
        'field': 'field',
        'match': 'match',
        'reply_to': 'replyTo',
        'subject': 'subject',
        '_from': 'from',
        'charset': 'charset',
        'is_html': 'isHTML',
        'ignore_reply_to': 'ignoreReplyTo',
        'body': 'body',
        'template_id': 'templateId',
        'template_variables': 'templateVariables'
    }

    def __init__(self, inbox_id=None, name=None, field=None, match=None, reply_to=None, subject=None, _from=None, charset=None, is_html=None, ignore_reply_to=None, body=None, template_id=None, template_variables=None, local_vars_configuration=None):  # noqa: E501
        """UpdateInboxReplierOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._inbox_id = None
        self._name = None
        self._field = None
        self._match = None
        self._reply_to = None
        self._subject = None
        self.__from = None
        self._charset = None
        self._is_html = None
        self._ignore_reply_to = None
        self._body = None
        self._template_id = None
        self._template_variables = None
        self.discriminator = None

        self.inbox_id = inbox_id
        self.name = name
        self.field = field
        self.match = match
        self.reply_to = reply_to
        self.subject = subject
        self._from = _from
        self.charset = charset
        self.is_html = is_html
        self.ignore_reply_to = ignore_reply_to
        self.body = body
        self.template_id = template_id
        self.template_variables = template_variables

    @property
    def inbox_id(self):
        """Gets the inbox_id of this UpdateInboxReplierOptions.  # noqa: E501

        Inbox ID to attach replier to  # noqa: E501

        :return: The inbox_id of this UpdateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this UpdateInboxReplierOptions.

        Inbox ID to attach replier to  # noqa: E501

        :param inbox_id: The inbox_id of this UpdateInboxReplierOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def name(self):
        """Gets the name of this UpdateInboxReplierOptions.  # noqa: E501

        Name for replier  # noqa: E501

        :return: The name of this UpdateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this UpdateInboxReplierOptions.

        Name for replier  # noqa: E501

        :param name: The name of this UpdateInboxReplierOptions.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def field(self):
        """Gets the field of this UpdateInboxReplierOptions.  # noqa: E501

        Field to match against to trigger inbox replier for inbound email  # noqa: E501

        :return: The field of this UpdateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._field

    @field.setter
    def field(self, field):
        """Sets the field of this UpdateInboxReplierOptions.

        Field to match against to trigger inbox replier for inbound email  # noqa: E501

        :param field: The field of this UpdateInboxReplierOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and field is None:  # noqa: E501
            raise ValueError("Invalid value for `field`, must not be `None`")  # noqa: E501
        allowed_values = ["RECIPIENTS", "SENDER", "SUBJECT", "ATTACHMENTS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and field not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `field` ({0}), must be one of {1}"  # noqa: E501
                .format(field, allowed_values)
            )

        self._field = field

    @property
    def match(self):
        """Gets the match of this UpdateInboxReplierOptions.  # noqa: E501

        String or wildcard style match for field specified when evaluating reply rules  # noqa: E501

        :return: The match of this UpdateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._match

    @match.setter
    def match(self, match):
        """Sets the match of this UpdateInboxReplierOptions.

        String or wildcard style match for field specified when evaluating reply rules  # noqa: E501

        :param match: The match of this UpdateInboxReplierOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and match is None:  # noqa: E501
            raise ValueError("Invalid value for `match`, must not be `None`")  # noqa: E501

        self._match = match

    @property
    def reply_to(self):
        """Gets the reply_to of this UpdateInboxReplierOptions.  # noqa: E501

        Reply-to email address when sending replying  # noqa: E501

        :return: The reply_to of this UpdateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._reply_to

    @reply_to.setter
    def reply_to(self, reply_to):
        """Sets the reply_to of this UpdateInboxReplierOptions.

        Reply-to email address when sending replying  # noqa: E501

        :param reply_to: The reply_to of this UpdateInboxReplierOptions.  # noqa: E501
        :type: str
        """

        self._reply_to = reply_to

    @property
    def subject(self):
        """Gets the subject of this UpdateInboxReplierOptions.  # noqa: E501

        Subject override when replying to email  # noqa: E501

        :return: The subject of this UpdateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this UpdateInboxReplierOptions.

        Subject override when replying to email  # noqa: E501

        :param subject: The subject of this UpdateInboxReplierOptions.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def _from(self):
        """Gets the _from of this UpdateInboxReplierOptions.  # noqa: E501

        Send email from address  # noqa: E501

        :return: The _from of this UpdateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self.__from

    @_from.setter
    def _from(self, _from):
        """Sets the _from of this UpdateInboxReplierOptions.

        Send email from address  # noqa: E501

        :param _from: The _from of this UpdateInboxReplierOptions.  # noqa: E501
        :type: str
        """

        self.__from = _from

    @property
    def charset(self):
        """Gets the charset of this UpdateInboxReplierOptions.  # noqa: E501

        Email reply charset  # noqa: E501

        :return: The charset of this UpdateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._charset

    @charset.setter
    def charset(self, charset):
        """Sets the charset of this UpdateInboxReplierOptions.

        Email reply charset  # noqa: E501

        :param charset: The charset of this UpdateInboxReplierOptions.  # noqa: E501
        :type: str
        """

        self._charset = charset

    @property
    def is_html(self):
        """Gets the is_html of this UpdateInboxReplierOptions.  # noqa: E501

        Send HTML email  # noqa: E501

        :return: The is_html of this UpdateInboxReplierOptions.  # noqa: E501
        :rtype: bool
        """
        return self._is_html

    @is_html.setter
    def is_html(self, is_html):
        """Sets the is_html of this UpdateInboxReplierOptions.

        Send HTML email  # noqa: E501

        :param is_html: The is_html of this UpdateInboxReplierOptions.  # noqa: E501
        :type: bool
        """

        self._is_html = is_html

    @property
    def ignore_reply_to(self):
        """Gets the ignore_reply_to of this UpdateInboxReplierOptions.  # noqa: E501

        Ignore sender replyTo when responding. Send directly to the sender if enabled.  # noqa: E501

        :return: The ignore_reply_to of this UpdateInboxReplierOptions.  # noqa: E501
        :rtype: bool
        """
        return self._ignore_reply_to

    @ignore_reply_to.setter
    def ignore_reply_to(self, ignore_reply_to):
        """Sets the ignore_reply_to of this UpdateInboxReplierOptions.

        Ignore sender replyTo when responding. Send directly to the sender if enabled.  # noqa: E501

        :param ignore_reply_to: The ignore_reply_to of this UpdateInboxReplierOptions.  # noqa: E501
        :type: bool
        """

        self._ignore_reply_to = ignore_reply_to

    @property
    def body(self):
        """Gets the body of this UpdateInboxReplierOptions.  # noqa: E501

        Email body for reply  # noqa: E501

        :return: The body of this UpdateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this UpdateInboxReplierOptions.

        Email body for reply  # noqa: E501

        :param body: The body of this UpdateInboxReplierOptions.  # noqa: E501
        :type: str
        """

        self._body = body

    @property
    def template_id(self):
        """Gets the template_id of this UpdateInboxReplierOptions.  # noqa: E501

        ID of template to use when sending a reply  # noqa: E501

        :return: The template_id of this UpdateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._template_id

    @template_id.setter
    def template_id(self, template_id):
        """Sets the template_id of this UpdateInboxReplierOptions.

        ID of template to use when sending a reply  # noqa: E501

        :param template_id: The template_id of this UpdateInboxReplierOptions.  # noqa: E501
        :type: str
        """

        self._template_id = template_id

    @property
    def template_variables(self):
        """Gets the template_variables of this UpdateInboxReplierOptions.  # noqa: E501

        Template variable values  # noqa: E501

        :return: The template_variables of this UpdateInboxReplierOptions.  # noqa: E501
        :rtype: dict(str, object)
        """
        return self._template_variables

    @template_variables.setter
    def template_variables(self, template_variables):
        """Sets the template_variables of this UpdateInboxReplierOptions.

        Template variable values  # noqa: E501

        :param template_variables: The template_variables of this UpdateInboxReplierOptions.  # noqa: E501
        :type: dict(str, object)
        """

        self._template_variables = template_variables

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, UpdateInboxReplierOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, UpdateInboxReplierOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/update_inbox_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class UpdateInboxOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'name': 'str',
        'description': 'str',
        'tags': 'list[str]',
        'expires_at': 'datetime',
        'favourite': 'bool'
    }

    attribute_map = {
        'name': 'name',
        'description': 'description',
        'tags': 'tags',
        'expires_at': 'expiresAt',
        'favourite': 'favourite'
    }

    def __init__(self, name=None, description=None, tags=None, expires_at=None, favourite=None, local_vars_configuration=None):  # noqa: E501
        """UpdateInboxOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._name = None
        self._description = None
        self._tags = None
        self._expires_at = None
        self._favourite = None
        self.discriminator = None

        self.name = name
        self.description = description
        self.tags = tags
        self.expires_at = expires_at
        self.favourite = favourite

    @property
    def name(self):
        """Gets the name of this UpdateInboxOptions.  # noqa: E501

        Name of the inbox and used as the sender name when sending emails .Displayed in the dashboard for easier search  # noqa: E501

        :return: The name of this UpdateInboxOptions.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this UpdateInboxOptions.

        Name of the inbox and used as the sender name when sending emails .Displayed in the dashboard for easier search  # noqa: E501

        :param name: The name of this UpdateInboxOptions.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def description(self):
        """Gets the description of this UpdateInboxOptions.  # noqa: E501

        Description of an inbox for labelling and searching purposes  # noqa: E501

        :return: The description of this UpdateInboxOptions.  # noqa: E501
        :rtype: str
        """
        return self._description

    @description.setter
    def description(self, description):
        """Sets the description of this UpdateInboxOptions.

        Description of an inbox for labelling and searching purposes  # noqa: E501

        :param description: The description of this UpdateInboxOptions.  # noqa: E501
        :type: str
        """

        self._description = description

    @property
    def tags(self):
        """Gets the tags of this UpdateInboxOptions.  # noqa: E501

        Tags that inbox has been tagged with. Tags can be added to inboxes to group different inboxes within an account. You can also search for inboxes by tag in the dashboard UI.  # noqa: E501

        :return: The tags of this UpdateInboxOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._tags

    @tags.setter
    def tags(self, tags):
        """Sets the tags of this UpdateInboxOptions.

        Tags that inbox has been tagged with. Tags can be added to inboxes to group different inboxes within an account. You can also search for inboxes by tag in the dashboard UI.  # noqa: E501

        :param tags: The tags of this UpdateInboxOptions.  # noqa: E501
        :type: list[str]
        """

        self._tags = tags

    @property
    def expires_at(self):
        """Gets the expires_at of this UpdateInboxOptions.  # noqa: E501

        Inbox expiration time. When, if ever, the inbox should expire and be deleted. If null then this inbox is permanent and the emails in it won't be deleted. This is the default behavior unless expiration date is set. If an expiration date is set and the time is reached MailSlurp will expire the inbox and move it to an expired inbox entity. You can still access the emails belonging to it but it can no longer send or receive email.  # noqa: E501

        :return: The expires_at of this UpdateInboxOptions.  # noqa: E501
        :rtype: datetime
        """
        return self._expires_at

    @expires_at.setter
    def expires_at(self, expires_at):
        """Sets the expires_at of this UpdateInboxOptions.

        Inbox expiration time. When, if ever, the inbox should expire and be deleted. If null then this inbox is permanent and the emails in it won't be deleted. This is the default behavior unless expiration date is set. If an expiration date is set and the time is reached MailSlurp will expire the inbox and move it to an expired inbox entity. You can still access the emails belonging to it but it can no longer send or receive email.  # noqa: E501

        :param expires_at: The expires_at of this UpdateInboxOptions.  # noqa: E501
        :type: datetime
        """

        self._expires_at = expires_at

    @property
    def favourite(self):
        """Gets the favourite of this UpdateInboxOptions.  # noqa: E501

        Is the inbox a favorite inbox. Make an inbox a favorite is typically done in the dashboard for quick access or filtering  # noqa: E501

        :return: The favourite of this UpdateInboxOptions.  # noqa: E501
        :rtype: bool
        """
        return self._favourite

    @favourite.setter
    def favourite(self, favourite):
        """Sets the favourite of this UpdateInboxOptions.

        Is the inbox a favorite inbox. Make an inbox a favorite is typically done in the dashboard for quick access or filtering  # noqa: E501

        :param favourite: The favourite of this UpdateInboxOptions.  # noqa: E501
        :type: bool
        """

        self._favourite = favourite

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, UpdateInboxOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, UpdateInboxOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/update_imap_access_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class UpdateImapAccessOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'imap_username': 'str',
        'imap_password': 'str'
    }

    attribute_map = {
        'imap_username': 'imapUsername',
        'imap_password': 'imapPassword'
    }

    def __init__(self, imap_username=None, imap_password=None, local_vars_configuration=None):  # noqa: E501
        """UpdateImapAccessOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._imap_username = None
        self._imap_password = None
        self.discriminator = None

        self.imap_username = imap_username
        self.imap_password = imap_password

    @property
    def imap_username(self):
        """Gets the imap_username of this UpdateImapAccessOptions.  # noqa: E501

        IMAP username for login  # noqa: E501

        :return: The imap_username of this UpdateImapAccessOptions.  # noqa: E501
        :rtype: str
        """
        return self._imap_username

    @imap_username.setter
    def imap_username(self, imap_username):
        """Sets the imap_username of this UpdateImapAccessOptions.

        IMAP username for login  # noqa: E501

        :param imap_username: The imap_username of this UpdateImapAccessOptions.  # noqa: E501
        :type: str
        """

        self._imap_username = imap_username

    @property
    def imap_password(self):
        """Gets the imap_password of this UpdateImapAccessOptions.  # noqa: E501

        IMAP password for login  # noqa: E501

        :return: The imap_password of this UpdateImapAccessOptions.  # noqa: E501
        :rtype: str
        """
        return self._imap_password

    @imap_password.setter
    def imap_password(self, imap_password):
        """Sets the imap_password of this UpdateImapAccessOptions.

        IMAP password for login  # noqa: E501

        :param imap_password: The imap_password of this UpdateImapAccessOptions.  # noqa: E501
        :type: str
        """

        self._imap_password = imap_password

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, UpdateImapAccessOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, UpdateImapAccessOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/update_group_contacts.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class UpdateGroupContacts(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'contact_ids': 'list[str]'
    }

    attribute_map = {
        'contact_ids': 'contactIds'
    }

    def __init__(self, contact_ids=None, local_vars_configuration=None):  # noqa: E501
        """UpdateGroupContacts - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._contact_ids = None
        self.discriminator = None

        self.contact_ids = contact_ids

    @property
    def contact_ids(self):
        """Gets the contact_ids of this UpdateGroupContacts.  # noqa: E501


        :return: The contact_ids of this UpdateGroupContacts.  # noqa: E501
        :rtype: list[str]
        """
        return self._contact_ids

    @contact_ids.setter
    def contact_ids(self, contact_ids):
        """Sets the contact_ids of this UpdateGroupContacts.


        :param contact_ids: The contact_ids of this UpdateGroupContacts.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and contact_ids is None:  # noqa: E501
            raise ValueError("Invalid value for `contact_ids`, must not be `None`")  # noqa: E501

        self._contact_ids = contact_ids

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, UpdateGroupContacts):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, UpdateGroupContacts):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/update_domain_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class UpdateDomainOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'catch_all_inbox_id': 'str'
    }

    attribute_map = {
        'catch_all_inbox_id': 'catchAllInboxId'
    }

    def __init__(self, catch_all_inbox_id=None, local_vars_configuration=None):  # noqa: E501
        """UpdateDomainOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._catch_all_inbox_id = None
        self.discriminator = None

        self.catch_all_inbox_id = catch_all_inbox_id

    @property
    def catch_all_inbox_id(self):
        """Gets the catch_all_inbox_id of this UpdateDomainOptions.  # noqa: E501


        :return: The catch_all_inbox_id of this UpdateDomainOptions.  # noqa: E501
        :rtype: str
        """
        return self._catch_all_inbox_id

    @catch_all_inbox_id.setter
    def catch_all_inbox_id(self, catch_all_inbox_id):
        """Sets the catch_all_inbox_id of this UpdateDomainOptions.


        :param catch_all_inbox_id: The catch_all_inbox_id of this UpdateDomainOptions.  # noqa: E501
        :type: str
        """

        self._catch_all_inbox_id = catch_all_inbox_id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, UpdateDomainOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, UpdateDomainOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/update_alias_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class UpdateAliasOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'name': 'str'
    }

    attribute_map = {
        'name': 'name'
    }

    def __init__(self, name=None, local_vars_configuration=None):  # noqa: E501
        """UpdateAliasOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._name = None
        self.discriminator = None

        self.name = name

    @property
    def name(self):
        """Gets the name of this UpdateAliasOptions.  # noqa: E501

        Optional name for alias  # noqa: E501

        :return: The name of this UpdateAliasOptions.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this UpdateAliasOptions.

        Optional name for alias  # noqa: E501

        :param name: The name of this UpdateAliasOptions.  # noqa: E501
        :type: str
        """

        self._name = name

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, UpdateAliasOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, UpdateAliasOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/unseen_error_count_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class UnseenErrorCountDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'count': 'int'
    }

    attribute_map = {
        'count': 'count'
    }

    def __init__(self, count=None, local_vars_configuration=None):  # noqa: E501
        """UnseenErrorCountDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._count = None
        self.discriminator = None

        self.count = count

    @property
    def count(self):
        """Gets the count of this UnseenErrorCountDto.  # noqa: E501


        :return: The count of this UnseenErrorCountDto.  # noqa: E501
        :rtype: int
        """
        return self._count

    @count.setter
    def count(self, count):
        """Sets the count of this UnseenErrorCountDto.


        :param count: The count of this UnseenErrorCountDto.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and count is None:  # noqa: E501
            raise ValueError("Invalid value for `count`, must not be `None`")  # noqa: E501

        self._count = count

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, UnseenErrorCountDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, UnseenErrorCountDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/unread_count.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class UnreadCount(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'count': 'int'
    }

    attribute_map = {
        'count': 'count'
    }

    def __init__(self, count=None, local_vars_configuration=None):  # noqa: E501
        """UnreadCount - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._count = None
        self.discriminator = None

        self.count = count

    @property
    def count(self):
        """Gets the count of this UnreadCount.  # noqa: E501


        :return: The count of this UnreadCount.  # noqa: E501
        :rtype: int
        """
        return self._count

    @count.setter
    def count(self, count):
        """Sets the count of this UnreadCount.


        :param count: The count of this UnreadCount.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and count is None:  # noqa: E501
            raise ValueError("Invalid value for `count`, must not be `None`")  # noqa: E501

        self._count = count

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, UnreadCount):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, UnreadCount):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/unknown_missed_email_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class UnknownMissedEmailProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'to': 'list[str]',
        'subject': 'str',
        'id': 'str',
        '_from': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'to': 'to',
        'subject': 'subject',
        'id': 'id',
        '_from': 'from'
    }

    def __init__(self, created_at=None, to=None, subject=None, id=None, _from=None, local_vars_configuration=None):  # noqa: E501
        """UnknownMissedEmailProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._to = None
        self._subject = None
        self._id = None
        self.__from = None
        self.discriminator = None

        self.created_at = created_at
        if to is not None:
            self.to = to
        if subject is not None:
            self.subject = subject
        self.id = id
        if _from is not None:
            self._from = _from

    @property
    def created_at(self):
        """Gets the created_at of this UnknownMissedEmailProjection.  # noqa: E501


        :return: The created_at of this UnknownMissedEmailProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this UnknownMissedEmailProjection.


        :param created_at: The created_at of this UnknownMissedEmailProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def to(self):
        """Gets the to of this UnknownMissedEmailProjection.  # noqa: E501


        :return: The to of this UnknownMissedEmailProjection.  # noqa: E501
        :rtype: list[str]
        """
        return self._to

    @to.setter
    def to(self, to):
        """Sets the to of this UnknownMissedEmailProjection.


        :param to: The to of this UnknownMissedEmailProjection.  # noqa: E501
        :type: list[str]
        """

        self._to = to

    @property
    def subject(self):
        """Gets the subject of this UnknownMissedEmailProjection.  # noqa: E501


        :return: The subject of this UnknownMissedEmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this UnknownMissedEmailProjection.


        :param subject: The subject of this UnknownMissedEmailProjection.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def id(self):
        """Gets the id of this UnknownMissedEmailProjection.  # noqa: E501


        :return: The id of this UnknownMissedEmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this UnknownMissedEmailProjection.


        :param id: The id of this UnknownMissedEmailProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def _from(self):
        """Gets the _from of this UnknownMissedEmailProjection.  # noqa: E501


        :return: The _from of this UnknownMissedEmailProjection.  # noqa: E501
        :rtype: str
        """
        return self.__from

    @_from.setter
    def _from(self, _from):
        """Sets the _from of this UnknownMissedEmailProjection.


        :param _from: The _from of this UnknownMissedEmailProjection.  # noqa: E501
        :type: str
        """

        self.__from = _from

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, UnknownMissedEmailProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, UnknownMissedEmailProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/tracking_pixel_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class TrackingPixelProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'inbox_id': 'str',
        'user_id': 'str',
        'sent_email_id': 'str',
        'recipient': 'str',
        'seen': 'bool',
        'seen_at': 'datetime',
        'name': 'str',
        'id': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'inbox_id': 'inboxId',
        'user_id': 'userId',
        'sent_email_id': 'sentEmailId',
        'recipient': 'recipient',
        'seen': 'seen',
        'seen_at': 'seenAt',
        'name': 'name',
        'id': 'id'
    }

    def __init__(self, created_at=None, inbox_id=None, user_id=None, sent_email_id=None, recipient=None, seen=None, seen_at=None, name=None, id=None, local_vars_configuration=None):  # noqa: E501
        """TrackingPixelProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._inbox_id = None
        self._user_id = None
        self._sent_email_id = None
        self._recipient = None
        self._seen = None
        self._seen_at = None
        self._name = None
        self._id = None
        self.discriminator = None

        self.created_at = created_at
        if inbox_id is not None:
            self.inbox_id = inbox_id
        self.user_id = user_id
        if sent_email_id is not None:
            self.sent_email_id = sent_email_id
        if recipient is not None:
            self.recipient = recipient
        self.seen = seen
        if seen_at is not None:
            self.seen_at = seen_at
        if name is not None:
            self.name = name
        self.id = id

    @property
    def created_at(self):
        """Gets the created_at of this TrackingPixelProjection.  # noqa: E501


        :return: The created_at of this TrackingPixelProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this TrackingPixelProjection.


        :param created_at: The created_at of this TrackingPixelProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def inbox_id(self):
        """Gets the inbox_id of this TrackingPixelProjection.  # noqa: E501


        :return: The inbox_id of this TrackingPixelProjection.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this TrackingPixelProjection.


        :param inbox_id: The inbox_id of this TrackingPixelProjection.  # noqa: E501
        :type: str
        """

        self._inbox_id = inbox_id

    @property
    def user_id(self):
        """Gets the user_id of this TrackingPixelProjection.  # noqa: E501


        :return: The user_id of this TrackingPixelProjection.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this TrackingPixelProjection.


        :param user_id: The user_id of this TrackingPixelProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def sent_email_id(self):
        """Gets the sent_email_id of this TrackingPixelProjection.  # noqa: E501


        :return: The sent_email_id of this TrackingPixelProjection.  # noqa: E501
        :rtype: str
        """
        return self._sent_email_id

    @sent_email_id.setter
    def sent_email_id(self, sent_email_id):
        """Sets the sent_email_id of this TrackingPixelProjection.


        :param sent_email_id: The sent_email_id of this TrackingPixelProjection.  # noqa: E501
        :type: str
        """

        self._sent_email_id = sent_email_id

    @property
    def recipient(self):
        """Gets the recipient of this TrackingPixelProjection.  # noqa: E501


        :return: The recipient of this TrackingPixelProjection.  # noqa: E501
        :rtype: str
        """
        return self._recipient

    @recipient.setter
    def recipient(self, recipient):
        """Sets the recipient of this TrackingPixelProjection.


        :param recipient: The recipient of this TrackingPixelProjection.  # noqa: E501
        :type: str
        """

        self._recipient = recipient

    @property
    def seen(self):
        """Gets the seen of this TrackingPixelProjection.  # noqa: E501


        :return: The seen of this TrackingPixelProjection.  # noqa: E501
        :rtype: bool
        """
        return self._seen

    @seen.setter
    def seen(self, seen):
        """Sets the seen of this TrackingPixelProjection.


        :param seen: The seen of this TrackingPixelProjection.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and seen is None:  # noqa: E501
            raise ValueError("Invalid value for `seen`, must not be `None`")  # noqa: E501

        self._seen = seen

    @property
    def seen_at(self):
        """Gets the seen_at of this TrackingPixelProjection.  # noqa: E501


        :return: The seen_at of this TrackingPixelProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._seen_at

    @seen_at.setter
    def seen_at(self, seen_at):
        """Sets the seen_at of this TrackingPixelProjection.


        :param seen_at: The seen_at of this TrackingPixelProjection.  # noqa: E501
        :type: datetime
        """

        self._seen_at = seen_at

    @property
    def name(self):
        """Gets the name of this TrackingPixelProjection.  # noqa: E501


        :return: The name of this TrackingPixelProjection.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this TrackingPixelProjection.


        :param name: The name of this TrackingPixelProjection.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def id(self):
        """Gets the id of this TrackingPixelProjection.  # noqa: E501


        :return: The id of this TrackingPixelProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this TrackingPixelProjection.


        :param id: The id of this TrackingPixelProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, TrackingPixelProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, TrackingPixelProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/tracking_pixel_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class TrackingPixelDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'seen': 'bool',
        'recipient': 'str',
        'html': 'str',
        'url': 'str',
        'inbox_id': 'str',
        'sent_email_id': 'str',
        'seen_at': 'datetime',
        'created_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'seen': 'seen',
        'recipient': 'recipient',
        'html': 'html',
        'url': 'url',
        'inbox_id': 'inboxId',
        'sent_email_id': 'sentEmailId',
        'seen_at': 'seenAt',
        'created_at': 'createdAt'
    }

    def __init__(self, id=None, seen=None, recipient=None, html=None, url=None, inbox_id=None, sent_email_id=None, seen_at=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """TrackingPixelDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._seen = None
        self._recipient = None
        self._html = None
        self._url = None
        self._inbox_id = None
        self._sent_email_id = None
        self._seen_at = None
        self._created_at = None
        self.discriminator = None

        self.id = id
        self.seen = seen
        self.recipient = recipient
        self.html = html
        self.url = url
        self.inbox_id = inbox_id
        self.sent_email_id = sent_email_id
        self.seen_at = seen_at
        self.created_at = created_at

    @property
    def id(self):
        """Gets the id of this TrackingPixelDto.  # noqa: E501


        :return: The id of this TrackingPixelDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this TrackingPixelDto.


        :param id: The id of this TrackingPixelDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def seen(self):
        """Gets the seen of this TrackingPixelDto.  # noqa: E501


        :return: The seen of this TrackingPixelDto.  # noqa: E501
        :rtype: bool
        """
        return self._seen

    @seen.setter
    def seen(self, seen):
        """Sets the seen of this TrackingPixelDto.


        :param seen: The seen of this TrackingPixelDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and seen is None:  # noqa: E501
            raise ValueError("Invalid value for `seen`, must not be `None`")  # noqa: E501

        self._seen = seen

    @property
    def recipient(self):
        """Gets the recipient of this TrackingPixelDto.  # noqa: E501


        :return: The recipient of this TrackingPixelDto.  # noqa: E501
        :rtype: str
        """
        return self._recipient

    @recipient.setter
    def recipient(self, recipient):
        """Sets the recipient of this TrackingPixelDto.


        :param recipient: The recipient of this TrackingPixelDto.  # noqa: E501
        :type: str
        """

        self._recipient = recipient

    @property
    def html(self):
        """Gets the html of this TrackingPixelDto.  # noqa: E501


        :return: The html of this TrackingPixelDto.  # noqa: E501
        :rtype: str
        """
        return self._html

    @html.setter
    def html(self, html):
        """Sets the html of this TrackingPixelDto.


        :param html: The html of this TrackingPixelDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and html is None:  # noqa: E501
            raise ValueError("Invalid value for `html`, must not be `None`")  # noqa: E501

        self._html = html

    @property
    def url(self):
        """Gets the url of this TrackingPixelDto.  # noqa: E501


        :return: The url of this TrackingPixelDto.  # noqa: E501
        :rtype: str
        """
        return self._url

    @url.setter
    def url(self, url):
        """Sets the url of this TrackingPixelDto.


        :param url: The url of this TrackingPixelDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and url is None:  # noqa: E501
            raise ValueError("Invalid value for `url`, must not be `None`")  # noqa: E501

        self._url = url

    @property
    def inbox_id(self):
        """Gets the inbox_id of this TrackingPixelDto.  # noqa: E501


        :return: The inbox_id of this TrackingPixelDto.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this TrackingPixelDto.


        :param inbox_id: The inbox_id of this TrackingPixelDto.  # noqa: E501
        :type: str
        """

        self._inbox_id = inbox_id

    @property
    def sent_email_id(self):
        """Gets the sent_email_id of this TrackingPixelDto.  # noqa: E501


        :return: The sent_email_id of this TrackingPixelDto.  # noqa: E501
        :rtype: str
        """
        return self._sent_email_id

    @sent_email_id.setter
    def sent_email_id(self, sent_email_id):
        """Sets the sent_email_id of this TrackingPixelDto.


        :param sent_email_id: The sent_email_id of this TrackingPixelDto.  # noqa: E501
        :type: str
        """

        self._sent_email_id = sent_email_id

    @property
    def seen_at(self):
        """Gets the seen_at of this TrackingPixelDto.  # noqa: E501


        :return: The seen_at of this TrackingPixelDto.  # noqa: E501
        :rtype: datetime
        """
        return self._seen_at

    @seen_at.setter
    def seen_at(self, seen_at):
        """Sets the seen_at of this TrackingPixelDto.


        :param seen_at: The seen_at of this TrackingPixelDto.  # noqa: E501
        :type: datetime
        """

        self._seen_at = seen_at

    @property
    def created_at(self):
        """Gets the created_at of this TrackingPixelDto.  # noqa: E501


        :return: The created_at of this TrackingPixelDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this TrackingPixelDto.


        :param created_at: The created_at of this TrackingPixelDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, TrackingPixelDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, TrackingPixelDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/thread_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ThreadProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'updated_at': 'datetime',
        'inbox_id': 'str',
        'user_id': 'str',
        'to': 'list[str]',
        'bcc': 'list[str]',
        'cc': 'list[str]',
        'alias_id': 'str',
        'subject': 'str',
        'name': 'str',
        'id': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'updated_at': 'updatedAt',
        'inbox_id': 'inboxId',
        'user_id': 'userId',
        'to': 'to',
        'bcc': 'bcc',
        'cc': 'cc',
        'alias_id': 'aliasId',
        'subject': 'subject',
        'name': 'name',
        'id': 'id'
    }

    def __init__(self, created_at=None, updated_at=None, inbox_id=None, user_id=None, to=None, bcc=None, cc=None, alias_id=None, subject=None, name=None, id=None, local_vars_configuration=None):  # noqa: E501
        """ThreadProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._updated_at = None
        self._inbox_id = None
        self._user_id = None
        self._to = None
        self._bcc = None
        self._cc = None
        self._alias_id = None
        self._subject = None
        self._name = None
        self._id = None
        self.discriminator = None

        self.created_at = created_at
        self.updated_at = updated_at
        self.inbox_id = inbox_id
        self.user_id = user_id
        self.to = to
        if bcc is not None:
            self.bcc = bcc
        if cc is not None:
            self.cc = cc
        self.alias_id = alias_id
        if subject is not None:
            self.subject = subject
        if name is not None:
            self.name = name
        self.id = id

    @property
    def created_at(self):
        """Gets the created_at of this ThreadProjection.  # noqa: E501

        Created at DateTime  # noqa: E501

        :return: The created_at of this ThreadProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this ThreadProjection.

        Created at DateTime  # noqa: E501

        :param created_at: The created_at of this ThreadProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this ThreadProjection.  # noqa: E501

        Updated at DateTime  # noqa: E501

        :return: The updated_at of this ThreadProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this ThreadProjection.

        Updated at DateTime  # noqa: E501

        :param updated_at: The updated_at of this ThreadProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    @property
    def inbox_id(self):
        """Gets the inbox_id of this ThreadProjection.  # noqa: E501

        Inbox ID  # noqa: E501

        :return: The inbox_id of this ThreadProjection.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this ThreadProjection.

        Inbox ID  # noqa: E501

        :param inbox_id: The inbox_id of this ThreadProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def user_id(self):
        """Gets the user_id of this ThreadProjection.  # noqa: E501

        User ID  # noqa: E501

        :return: The user_id of this ThreadProjection.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this ThreadProjection.

        User ID  # noqa: E501

        :param user_id: The user_id of this ThreadProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def to(self):
        """Gets the to of this ThreadProjection.  # noqa: E501

        To recipients  # noqa: E501

        :return: The to of this ThreadProjection.  # noqa: E501
        :rtype: list[str]
        """
        return self._to

    @to.setter
    def to(self, to):
        """Sets the to of this ThreadProjection.

        To recipients  # noqa: E501

        :param to: The to of this ThreadProjection.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and to is None:  # noqa: E501
            raise ValueError("Invalid value for `to`, must not be `None`")  # noqa: E501

        self._to = to

    @property
    def bcc(self):
        """Gets the bcc of this ThreadProjection.  # noqa: E501

        BCC recipients  # noqa: E501

        :return: The bcc of this ThreadProjection.  # noqa: E501
        :rtype: list[str]
        """
        return self._bcc

    @bcc.setter
    def bcc(self, bcc):
        """Sets the bcc of this ThreadProjection.

        BCC recipients  # noqa: E501

        :param bcc: The bcc of this ThreadProjection.  # noqa: E501
        :type: list[str]
        """

        self._bcc = bcc

    @property
    def cc(self):
        """Gets the cc of this ThreadProjection.  # noqa: E501

        CC recipients  # noqa: E501

        :return: The cc of this ThreadProjection.  # noqa: E501
        :rtype: list[str]
        """
        return self._cc

    @cc.setter
    def cc(self, cc):
        """Sets the cc of this ThreadProjection.

        CC recipients  # noqa: E501

        :param cc: The cc of this ThreadProjection.  # noqa: E501
        :type: list[str]
        """

        self._cc = cc

    @property
    def alias_id(self):
        """Gets the alias_id of this ThreadProjection.  # noqa: E501

        Alias ID  # noqa: E501

        :return: The alias_id of this ThreadProjection.  # noqa: E501
        :rtype: str
        """
        return self._alias_id

    @alias_id.setter
    def alias_id(self, alias_id):
        """Sets the alias_id of this ThreadProjection.

        Alias ID  # noqa: E501

        :param alias_id: The alias_id of this ThreadProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and alias_id is None:  # noqa: E501
            raise ValueError("Invalid value for `alias_id`, must not be `None`")  # noqa: E501

        self._alias_id = alias_id

    @property
    def subject(self):
        """Gets the subject of this ThreadProjection.  # noqa: E501

        Thread subject  # noqa: E501

        :return: The subject of this ThreadProjection.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this ThreadProjection.

        Thread subject  # noqa: E501

        :param subject: The subject of this ThreadProjection.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def name(self):
        """Gets the name of this ThreadProjection.  # noqa: E501

        Name of thread  # noqa: E501

        :return: The name of this ThreadProjection.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this ThreadProjection.

        Name of thread  # noqa: E501

        :param name: The name of this ThreadProjection.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def id(self):
        """Gets the id of this ThreadProjection.  # noqa: E501

        ID of email thread  # noqa: E501

        :return: The id of this ThreadProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this ThreadProjection.

        ID of email thread  # noqa: E501

        :param id: The id of this ThreadProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ThreadProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ThreadProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/test_phone_number_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class TestPhoneNumberOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'message': 'str'
    }

    attribute_map = {
        'message': 'message'
    }

    def __init__(self, message=None, local_vars_configuration=None):  # noqa: E501
        """TestPhoneNumberOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._message = None
        self.discriminator = None

        self.message = message

    @property
    def message(self):
        """Gets the message of this TestPhoneNumberOptions.  # noqa: E501


        :return: The message of this TestPhoneNumberOptions.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this TestPhoneNumberOptions.


        :param message: The message of this TestPhoneNumberOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and message is None:  # noqa: E501
            raise ValueError("Invalid value for `message`, must not be `None`")  # noqa: E501

        self._message = message

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, TestPhoneNumberOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, TestPhoneNumberOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/test_new_inbox_ruleset_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class TestNewInboxRulesetOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'inbox_ruleset_test_options': 'InboxRulesetTestOptions',
        'create_inbox_ruleset_options': 'CreateInboxRulesetOptions'
    }

    attribute_map = {
        'inbox_ruleset_test_options': 'inboxRulesetTestOptions',
        'create_inbox_ruleset_options': 'createInboxRulesetOptions'
    }

    def __init__(self, inbox_ruleset_test_options=None, create_inbox_ruleset_options=None, local_vars_configuration=None):  # noqa: E501
        """TestNewInboxRulesetOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._inbox_ruleset_test_options = None
        self._create_inbox_ruleset_options = None
        self.discriminator = None

        self.inbox_ruleset_test_options = inbox_ruleset_test_options
        self.create_inbox_ruleset_options = create_inbox_ruleset_options

    @property
    def inbox_ruleset_test_options(self):
        """Gets the inbox_ruleset_test_options of this TestNewInboxRulesetOptions.  # noqa: E501


        :return: The inbox_ruleset_test_options of this TestNewInboxRulesetOptions.  # noqa: E501
        :rtype: InboxRulesetTestOptions
        """
        return self._inbox_ruleset_test_options

    @inbox_ruleset_test_options.setter
    def inbox_ruleset_test_options(self, inbox_ruleset_test_options):
        """Sets the inbox_ruleset_test_options of this TestNewInboxRulesetOptions.


        :param inbox_ruleset_test_options: The inbox_ruleset_test_options of this TestNewInboxRulesetOptions.  # noqa: E501
        :type: InboxRulesetTestOptions
        """
        if self.local_vars_configuration.client_side_validation and inbox_ruleset_test_options is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_ruleset_test_options`, must not be `None`")  # noqa: E501

        self._inbox_ruleset_test_options = inbox_ruleset_test_options

    @property
    def create_inbox_ruleset_options(self):
        """Gets the create_inbox_ruleset_options of this TestNewInboxRulesetOptions.  # noqa: E501


        :return: The create_inbox_ruleset_options of this TestNewInboxRulesetOptions.  # noqa: E501
        :rtype: CreateInboxRulesetOptions
        """
        return self._create_inbox_ruleset_options

    @create_inbox_ruleset_options.setter
    def create_inbox_ruleset_options(self, create_inbox_ruleset_options):
        """Sets the create_inbox_ruleset_options of this TestNewInboxRulesetOptions.


        :param create_inbox_ruleset_options: The create_inbox_ruleset_options of this TestNewInboxRulesetOptions.  # noqa: E501
        :type: CreateInboxRulesetOptions
        """
        if self.local_vars_configuration.client_side_validation and create_inbox_ruleset_options is None:  # noqa: E501
            raise ValueError("Invalid value for `create_inbox_ruleset_options`, must not be `None`")  # noqa: E501

        self._create_inbox_ruleset_options = create_inbox_ruleset_options

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, TestNewInboxRulesetOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, TestNewInboxRulesetOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/test_new_inbox_forwarder_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class TestNewInboxForwarderOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'inbox_forwarder_test_options': 'InboxForwarderTestOptions',
        'create_inbox_forwarder_options': 'CreateInboxForwarderOptions'
    }

    attribute_map = {
        'inbox_forwarder_test_options': 'inboxForwarderTestOptions',
        'create_inbox_forwarder_options': 'createInboxForwarderOptions'
    }

    def __init__(self, inbox_forwarder_test_options=None, create_inbox_forwarder_options=None, local_vars_configuration=None):  # noqa: E501
        """TestNewInboxForwarderOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._inbox_forwarder_test_options = None
        self._create_inbox_forwarder_options = None
        self.discriminator = None

        self.inbox_forwarder_test_options = inbox_forwarder_test_options
        self.create_inbox_forwarder_options = create_inbox_forwarder_options

    @property
    def inbox_forwarder_test_options(self):
        """Gets the inbox_forwarder_test_options of this TestNewInboxForwarderOptions.  # noqa: E501


        :return: The inbox_forwarder_test_options of this TestNewInboxForwarderOptions.  # noqa: E501
        :rtype: InboxForwarderTestOptions
        """
        return self._inbox_forwarder_test_options

    @inbox_forwarder_test_options.setter
    def inbox_forwarder_test_options(self, inbox_forwarder_test_options):
        """Sets the inbox_forwarder_test_options of this TestNewInboxForwarderOptions.


        :param inbox_forwarder_test_options: The inbox_forwarder_test_options of this TestNewInboxForwarderOptions.  # noqa: E501
        :type: InboxForwarderTestOptions
        """
        if self.local_vars_configuration.client_side_validation and inbox_forwarder_test_options is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_forwarder_test_options`, must not be `None`")  # noqa: E501

        self._inbox_forwarder_test_options = inbox_forwarder_test_options

    @property
    def create_inbox_forwarder_options(self):
        """Gets the create_inbox_forwarder_options of this TestNewInboxForwarderOptions.  # noqa: E501


        :return: The create_inbox_forwarder_options of this TestNewInboxForwarderOptions.  # noqa: E501
        :rtype: CreateInboxForwarderOptions
        """
        return self._create_inbox_forwarder_options

    @create_inbox_forwarder_options.setter
    def create_inbox_forwarder_options(self, create_inbox_forwarder_options):
        """Sets the create_inbox_forwarder_options of this TestNewInboxForwarderOptions.


        :param create_inbox_forwarder_options: The create_inbox_forwarder_options of this TestNewInboxForwarderOptions.  # noqa: E501
        :type: CreateInboxForwarderOptions
        """
        if self.local_vars_configuration.client_side_validation and create_inbox_forwarder_options is None:  # noqa: E501
            raise ValueError("Invalid value for `create_inbox_forwarder_options`, must not be `None`")  # noqa: E501

        self._create_inbox_forwarder_options = create_inbox_forwarder_options

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, TestNewInboxForwarderOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, TestNewInboxForwarderOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/test_inbox_ruleset_sending_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class TestInboxRulesetSendingResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'can_send': 'bool'
    }

    attribute_map = {
        'can_send': 'canSend'
    }

    def __init__(self, can_send=None, local_vars_configuration=None):  # noqa: E501
        """TestInboxRulesetSendingResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._can_send = None
        self.discriminator = None

        self.can_send = can_send

    @property
    def can_send(self):
        """Gets the can_send of this TestInboxRulesetSendingResult.  # noqa: E501


        :return: The can_send of this TestInboxRulesetSendingResult.  # noqa: E501
        :rtype: bool
        """
        return self._can_send

    @can_send.setter
    def can_send(self, can_send):
        """Sets the can_send of this TestInboxRulesetSendingResult.


        :param can_send: The can_send of this TestInboxRulesetSendingResult.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and can_send is None:  # noqa: E501
            raise ValueError("Invalid value for `can_send`, must not be `None`")  # noqa: E501

        self._can_send = can_send

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, TestInboxRulesetSendingResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, TestInboxRulesetSendingResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/test_inbox_ruleset_sending_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class TestInboxRulesetSendingOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'inbox_id': 'str',
        'recipient': 'str'
    }

    attribute_map = {
        'inbox_id': 'inboxId',
        'recipient': 'recipient'
    }

    def __init__(self, inbox_id=None, recipient=None, local_vars_configuration=None):  # noqa: E501
        """TestInboxRulesetSendingOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._inbox_id = None
        self._recipient = None
        self.discriminator = None

        self.inbox_id = inbox_id
        self.recipient = recipient

    @property
    def inbox_id(self):
        """Gets the inbox_id of this TestInboxRulesetSendingOptions.  # noqa: E501


        :return: The inbox_id of this TestInboxRulesetSendingOptions.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this TestInboxRulesetSendingOptions.


        :param inbox_id: The inbox_id of this TestInboxRulesetSendingOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def recipient(self):
        """Gets the recipient of this TestInboxRulesetSendingOptions.  # noqa: E501


        :return: The recipient of this TestInboxRulesetSendingOptions.  # noqa: E501
        :rtype: str
        """
        return self._recipient

    @recipient.setter
    def recipient(self, recipient):
        """Sets the recipient of this TestInboxRulesetSendingOptions.


        :param recipient: The recipient of this TestInboxRulesetSendingOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and recipient is None:  # noqa: E501
            raise ValueError("Invalid value for `recipient`, must not be `None`")  # noqa: E501

        self._recipient = recipient

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, TestInboxRulesetSendingOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, TestInboxRulesetSendingOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/test_inbox_ruleset_receiving_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class TestInboxRulesetReceivingResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'can_receive': 'bool'
    }

    attribute_map = {
        'can_receive': 'canReceive'
    }

    def __init__(self, can_receive=None, local_vars_configuration=None):  # noqa: E501
        """TestInboxRulesetReceivingResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._can_receive = None
        self.discriminator = None

        self.can_receive = can_receive

    @property
    def can_receive(self):
        """Gets the can_receive of this TestInboxRulesetReceivingResult.  # noqa: E501


        :return: The can_receive of this TestInboxRulesetReceivingResult.  # noqa: E501
        :rtype: bool
        """
        return self._can_receive

    @can_receive.setter
    def can_receive(self, can_receive):
        """Sets the can_receive of this TestInboxRulesetReceivingResult.


        :param can_receive: The can_receive of this TestInboxRulesetReceivingResult.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and can_receive is None:  # noqa: E501
            raise ValueError("Invalid value for `can_receive`, must not be `None`")  # noqa: E501

        self._can_receive = can_receive

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, TestInboxRulesetReceivingResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, TestInboxRulesetReceivingResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/test_inbox_ruleset_receiving_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class TestInboxRulesetReceivingOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'inbox_id': 'str',
        'from_sender': 'str'
    }

    attribute_map = {
        'inbox_id': 'inboxId',
        'from_sender': 'fromSender'
    }

    def __init__(self, inbox_id=None, from_sender=None, local_vars_configuration=None):  # noqa: E501
        """TestInboxRulesetReceivingOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._inbox_id = None
        self._from_sender = None
        self.discriminator = None

        self.inbox_id = inbox_id
        self.from_sender = from_sender

    @property
    def inbox_id(self):
        """Gets the inbox_id of this TestInboxRulesetReceivingOptions.  # noqa: E501


        :return: The inbox_id of this TestInboxRulesetReceivingOptions.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this TestInboxRulesetReceivingOptions.


        :param inbox_id: The inbox_id of this TestInboxRulesetReceivingOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def from_sender(self):
        """Gets the from_sender of this TestInboxRulesetReceivingOptions.  # noqa: E501


        :return: The from_sender of this TestInboxRulesetReceivingOptions.  # noqa: E501
        :rtype: str
        """
        return self._from_sender

    @from_sender.setter
    def from_sender(self, from_sender):
        """Sets the from_sender of this TestInboxRulesetReceivingOptions.


        :param from_sender: The from_sender of this TestInboxRulesetReceivingOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and from_sender is None:  # noqa: E501
            raise ValueError("Invalid value for `from_sender`, must not be `None`")  # noqa: E501

        self._from_sender = from_sender

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, TestInboxRulesetReceivingOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, TestInboxRulesetReceivingOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/template_variable.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class TemplateVariable(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'name': 'str',
        'variable_type': 'str'
    }

    attribute_map = {
        'name': 'name',
        'variable_type': 'variableType'
    }

    def __init__(self, name=None, variable_type=None, local_vars_configuration=None):  # noqa: E501
        """TemplateVariable - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._name = None
        self._variable_type = None
        self.discriminator = None

        self.name = name
        self.variable_type = variable_type

    @property
    def name(self):
        """Gets the name of this TemplateVariable.  # noqa: E501

        Name of variable. This can be used in a template as {{name}}  # noqa: E501

        :return: The name of this TemplateVariable.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this TemplateVariable.

        Name of variable. This can be used in a template as {{name}}  # noqa: E501

        :param name: The name of this TemplateVariable.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    @property
    def variable_type(self):
        """Gets the variable_type of this TemplateVariable.  # noqa: E501

        The type of variable  # noqa: E501

        :return: The variable_type of this TemplateVariable.  # noqa: E501
        :rtype: str
        """
        return self._variable_type

    @variable_type.setter
    def variable_type(self, variable_type):
        """Sets the variable_type of this TemplateVariable.

        The type of variable  # noqa: E501

        :param variable_type: The variable_type of this TemplateVariable.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and variable_type is None:  # noqa: E501
            raise ValueError("Invalid value for `variable_type`, must not be `None`")  # noqa: E501
        allowed_values = ["STRING"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and variable_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `variable_type` ({0}), must be one of {1}"  # noqa: E501
                .format(variable_type, allowed_values)
            )

        self._variable_type = variable_type

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, TemplateVariable):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, TemplateVariable):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/template_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class TemplateProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'updated_at': 'datetime',
        'variables': 'list[str]',
        'name': 'str',
        'id': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'updated_at': 'updatedAt',
        'variables': 'variables',
        'name': 'name',
        'id': 'id'
    }

    def __init__(self, created_at=None, updated_at=None, variables=None, name=None, id=None, local_vars_configuration=None):  # noqa: E501
        """TemplateProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._updated_at = None
        self._variables = None
        self._name = None
        self._id = None
        self.discriminator = None

        self.created_at = created_at
        self.updated_at = updated_at
        self.variables = variables
        self.name = name
        self.id = id

    @property
    def created_at(self):
        """Gets the created_at of this TemplateProjection.  # noqa: E501


        :return: The created_at of this TemplateProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this TemplateProjection.


        :param created_at: The created_at of this TemplateProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this TemplateProjection.  # noqa: E501


        :return: The updated_at of this TemplateProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this TemplateProjection.


        :param updated_at: The updated_at of this TemplateProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    @property
    def variables(self):
        """Gets the variables of this TemplateProjection.  # noqa: E501


        :return: The variables of this TemplateProjection.  # noqa: E501
        :rtype: list[str]
        """
        return self._variables

    @variables.setter
    def variables(self, variables):
        """Sets the variables of this TemplateProjection.


        :param variables: The variables of this TemplateProjection.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and variables is None:  # noqa: E501
            raise ValueError("Invalid value for `variables`, must not be `None`")  # noqa: E501

        self._variables = variables

    @property
    def name(self):
        """Gets the name of this TemplateProjection.  # noqa: E501


        :return: The name of this TemplateProjection.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this TemplateProjection.


        :param name: The name of this TemplateProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    @property
    def id(self):
        """Gets the id of this TemplateProjection.  # noqa: E501


        :return: The id of this TemplateProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this TemplateProjection.


        :param id: The id of this TemplateProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, TemplateProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, TemplateProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/template_preview.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class TemplatePreview(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'preview': 'str'
    }

    attribute_map = {
        'preview': 'preview'
    }

    def __init__(self, preview=None, local_vars_configuration=None):  # noqa: E501
        """TemplatePreview - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._preview = None
        self.discriminator = None

        self.preview = preview

    @property
    def preview(self):
        """Gets the preview of this TemplatePreview.  # noqa: E501


        :return: The preview of this TemplatePreview.  # noqa: E501
        :rtype: str
        """
        return self._preview

    @preview.setter
    def preview(self, preview):
        """Sets the preview of this TemplatePreview.


        :param preview: The preview of this TemplatePreview.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and preview is None:  # noqa: E501
            raise ValueError("Invalid value for `preview`, must not be `None`")  # noqa: E501

        self._preview = preview

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, TemplatePreview):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, TemplatePreview):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/template_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class TemplateDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'name': 'str',
        'variables': 'list[TemplateVariable]',
        'content': 'str',
        'created_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'name': 'name',
        'variables': 'variables',
        'content': 'content',
        'created_at': 'createdAt'
    }

    def __init__(self, id=None, name=None, variables=None, content=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """TemplateDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._name = None
        self._variables = None
        self._content = None
        self._created_at = None
        self.discriminator = None

        self.id = id
        self.name = name
        self.variables = variables
        self.content = content
        self.created_at = created_at

    @property
    def id(self):
        """Gets the id of this TemplateDto.  # noqa: E501

        ID of template  # noqa: E501

        :return: The id of this TemplateDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this TemplateDto.

        ID of template  # noqa: E501

        :param id: The id of this TemplateDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def name(self):
        """Gets the name of this TemplateDto.  # noqa: E501

        Template name  # noqa: E501

        :return: The name of this TemplateDto.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this TemplateDto.

        Template name  # noqa: E501

        :param name: The name of this TemplateDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    @property
    def variables(self):
        """Gets the variables of this TemplateDto.  # noqa: E501

        Variables available in template that can be replaced with values  # noqa: E501

        :return: The variables of this TemplateDto.  # noqa: E501
        :rtype: list[TemplateVariable]
        """
        return self._variables

    @variables.setter
    def variables(self, variables):
        """Sets the variables of this TemplateDto.

        Variables available in template that can be replaced with values  # noqa: E501

        :param variables: The variables of this TemplateDto.  # noqa: E501
        :type: list[TemplateVariable]
        """
        if self.local_vars_configuration.client_side_validation and variables is None:  # noqa: E501
            raise ValueError("Invalid value for `variables`, must not be `None`")  # noqa: E501

        self._variables = variables

    @property
    def content(self):
        """Gets the content of this TemplateDto.  # noqa: E501

        Content of the template  # noqa: E501

        :return: The content of this TemplateDto.  # noqa: E501
        :rtype: str
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this TemplateDto.

        Content of the template  # noqa: E501

        :param content: The content of this TemplateDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and content is None:  # noqa: E501
            raise ValueError("Invalid value for `content`, must not be `None`")  # noqa: E501

        self._content = content

    @property
    def created_at(self):
        """Gets the created_at of this TemplateDto.  # noqa: E501

        Created at time  # noqa: E501

        :return: The created_at of this TemplateDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this TemplateDto.

        Created at time  # noqa: E501

        :param created_at: The created_at of this TemplateDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, TemplateDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, TemplateDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/spelling_issue.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SpellingIssue(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'group': 'str',
        'suggestion': 'str',
        'severity': 'str',
        'message': 'str'
    }

    attribute_map = {
        'group': 'group',
        'suggestion': 'suggestion',
        'severity': 'severity',
        'message': 'message'
    }

    def __init__(self, group=None, suggestion=None, severity=None, message=None, local_vars_configuration=None):  # noqa: E501
        """SpellingIssue - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._group = None
        self._suggestion = None
        self._severity = None
        self._message = None
        self.discriminator = None

        self.group = group
        self.suggestion = suggestion
        self.severity = severity
        self.message = message

    @property
    def group(self):
        """Gets the group of this SpellingIssue.  # noqa: E501


        :return: The group of this SpellingIssue.  # noqa: E501
        :rtype: str
        """
        return self._group

    @group.setter
    def group(self, group):
        """Sets the group of this SpellingIssue.


        :param group: The group of this SpellingIssue.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and group is None:  # noqa: E501
            raise ValueError("Invalid value for `group`, must not be `None`")  # noqa: E501

        self._group = group

    @property
    def suggestion(self):
        """Gets the suggestion of this SpellingIssue.  # noqa: E501


        :return: The suggestion of this SpellingIssue.  # noqa: E501
        :rtype: str
        """
        return self._suggestion

    @suggestion.setter
    def suggestion(self, suggestion):
        """Sets the suggestion of this SpellingIssue.


        :param suggestion: The suggestion of this SpellingIssue.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and suggestion is None:  # noqa: E501
            raise ValueError("Invalid value for `suggestion`, must not be `None`")  # noqa: E501

        self._suggestion = suggestion

    @property
    def severity(self):
        """Gets the severity of this SpellingIssue.  # noqa: E501


        :return: The severity of this SpellingIssue.  # noqa: E501
        :rtype: str
        """
        return self._severity

    @severity.setter
    def severity(self, severity):
        """Sets the severity of this SpellingIssue.


        :param severity: The severity of this SpellingIssue.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and severity is None:  # noqa: E501
            raise ValueError("Invalid value for `severity`, must not be `None`")  # noqa: E501
        allowed_values = ["Warning", "Error"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and severity not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `severity` ({0}), must be one of {1}"  # noqa: E501
                .format(severity, allowed_values)
            )

        self._severity = severity

    @property
    def message(self):
        """Gets the message of this SpellingIssue.  # noqa: E501


        :return: The message of this SpellingIssue.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this SpellingIssue.


        :param message: The message of this SpellingIssue.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and message is None:  # noqa: E501
            raise ValueError("Invalid value for `message`, must not be `None`")  # noqa: E501

        self._message = message

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SpellingIssue):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SpellingIssue):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/sort_object.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SortObject(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'sorted': 'bool',
        'unsorted': 'bool',
        'empty': 'bool'
    }

    attribute_map = {
        'sorted': 'sorted',
        'unsorted': 'unsorted',
        'empty': 'empty'
    }

    def __init__(self, sorted=None, unsorted=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """SortObject - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._sorted = None
        self._unsorted = None
        self._empty = None
        self.discriminator = None

        if sorted is not None:
            self.sorted = sorted
        if unsorted is not None:
            self.unsorted = unsorted
        if empty is not None:
            self.empty = empty

    @property
    def sorted(self):
        """Gets the sorted of this SortObject.  # noqa: E501


        :return: The sorted of this SortObject.  # noqa: E501
        :rtype: bool
        """
        return self._sorted

    @sorted.setter
    def sorted(self, sorted):
        """Sets the sorted of this SortObject.


        :param sorted: The sorted of this SortObject.  # noqa: E501
        :type: bool
        """

        self._sorted = sorted

    @property
    def unsorted(self):
        """Gets the unsorted of this SortObject.  # noqa: E501


        :return: The unsorted of this SortObject.  # noqa: E501
        :rtype: bool
        """
        return self._unsorted

    @unsorted.setter
    def unsorted(self, unsorted):
        """Sets the unsorted of this SortObject.


        :param unsorted: The unsorted of this SortObject.  # noqa: E501
        :type: bool
        """

        self._unsorted = unsorted

    @property
    def empty(self):
        """Gets the empty of this SortObject.  # noqa: E501


        :return: The empty of this SortObject.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this SortObject.


        :param empty: The empty of this SortObject.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SortObject):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SortObject):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/smtp_access_details.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SmtpAccessDetails(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'secure_smtp_server_host': 'str',
        'secure_smtp_server_port': 'int',
        'secure_smtp_username': 'str',
        'secure_smtp_password': 'str',
        'smtp_server_host': 'str',
        'smtp_server_port': 'int',
        'smtp_username': 'str',
        'smtp_password': 'str',
        'mail_from_domain': 'str'
    }

    attribute_map = {
        'secure_smtp_server_host': 'secureSmtpServerHost',
        'secure_smtp_server_port': 'secureSmtpServerPort',
        'secure_smtp_username': 'secureSmtpUsername',
        'secure_smtp_password': 'secureSmtpPassword',
        'smtp_server_host': 'smtpServerHost',
        'smtp_server_port': 'smtpServerPort',
        'smtp_username': 'smtpUsername',
        'smtp_password': 'smtpPassword',
        'mail_from_domain': 'mailFromDomain'
    }

    def __init__(self, secure_smtp_server_host=None, secure_smtp_server_port=None, secure_smtp_username=None, secure_smtp_password=None, smtp_server_host=None, smtp_server_port=None, smtp_username=None, smtp_password=None, mail_from_domain=None, local_vars_configuration=None):  # noqa: E501
        """SmtpAccessDetails - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._secure_smtp_server_host = None
        self._secure_smtp_server_port = None
        self._secure_smtp_username = None
        self._secure_smtp_password = None
        self._smtp_server_host = None
        self._smtp_server_port = None
        self._smtp_username = None
        self._smtp_password = None
        self._mail_from_domain = None
        self.discriminator = None

        self.secure_smtp_server_host = secure_smtp_server_host
        self.secure_smtp_server_port = secure_smtp_server_port
        self.secure_smtp_username = secure_smtp_username
        self.secure_smtp_password = secure_smtp_password
        self.smtp_server_host = smtp_server_host
        self.smtp_server_port = smtp_server_port
        self.smtp_username = smtp_username
        self.smtp_password = smtp_password
        self.mail_from_domain = mail_from_domain

    @property
    def secure_smtp_server_host(self):
        """Gets the secure_smtp_server_host of this SmtpAccessDetails.  # noqa: E501

        Secure TLS SMTP server host domain  # noqa: E501

        :return: The secure_smtp_server_host of this SmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._secure_smtp_server_host

    @secure_smtp_server_host.setter
    def secure_smtp_server_host(self, secure_smtp_server_host):
        """Sets the secure_smtp_server_host of this SmtpAccessDetails.

        Secure TLS SMTP server host domain  # noqa: E501

        :param secure_smtp_server_host: The secure_smtp_server_host of this SmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and secure_smtp_server_host is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_smtp_server_host`, must not be `None`")  # noqa: E501

        self._secure_smtp_server_host = secure_smtp_server_host

    @property
    def secure_smtp_server_port(self):
        """Gets the secure_smtp_server_port of this SmtpAccessDetails.  # noqa: E501

        Secure TLS SMTP server host port  # noqa: E501

        :return: The secure_smtp_server_port of this SmtpAccessDetails.  # noqa: E501
        :rtype: int
        """
        return self._secure_smtp_server_port

    @secure_smtp_server_port.setter
    def secure_smtp_server_port(self, secure_smtp_server_port):
        """Sets the secure_smtp_server_port of this SmtpAccessDetails.

        Secure TLS SMTP server host port  # noqa: E501

        :param secure_smtp_server_port: The secure_smtp_server_port of this SmtpAccessDetails.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and secure_smtp_server_port is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_smtp_server_port`, must not be `None`")  # noqa: E501

        self._secure_smtp_server_port = secure_smtp_server_port

    @property
    def secure_smtp_username(self):
        """Gets the secure_smtp_username of this SmtpAccessDetails.  # noqa: E501

        Secure TLS SMTP username for login  # noqa: E501

        :return: The secure_smtp_username of this SmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._secure_smtp_username

    @secure_smtp_username.setter
    def secure_smtp_username(self, secure_smtp_username):
        """Sets the secure_smtp_username of this SmtpAccessDetails.

        Secure TLS SMTP username for login  # noqa: E501

        :param secure_smtp_username: The secure_smtp_username of this SmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and secure_smtp_username is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_smtp_username`, must not be `None`")  # noqa: E501

        self._secure_smtp_username = secure_smtp_username

    @property
    def secure_smtp_password(self):
        """Gets the secure_smtp_password of this SmtpAccessDetails.  # noqa: E501

        Secure TLS SMTP password for login  # noqa: E501

        :return: The secure_smtp_password of this SmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._secure_smtp_password

    @secure_smtp_password.setter
    def secure_smtp_password(self, secure_smtp_password):
        """Sets the secure_smtp_password of this SmtpAccessDetails.

        Secure TLS SMTP password for login  # noqa: E501

        :param secure_smtp_password: The secure_smtp_password of this SmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and secure_smtp_password is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_smtp_password`, must not be `None`")  # noqa: E501

        self._secure_smtp_password = secure_smtp_password

    @property
    def smtp_server_host(self):
        """Gets the smtp_server_host of this SmtpAccessDetails.  # noqa: E501

        SMTP server host domain  # noqa: E501

        :return: The smtp_server_host of this SmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._smtp_server_host

    @smtp_server_host.setter
    def smtp_server_host(self, smtp_server_host):
        """Sets the smtp_server_host of this SmtpAccessDetails.

        SMTP server host domain  # noqa: E501

        :param smtp_server_host: The smtp_server_host of this SmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and smtp_server_host is None:  # noqa: E501
            raise ValueError("Invalid value for `smtp_server_host`, must not be `None`")  # noqa: E501

        self._smtp_server_host = smtp_server_host

    @property
    def smtp_server_port(self):
        """Gets the smtp_server_port of this SmtpAccessDetails.  # noqa: E501

        SMTP server host port  # noqa: E501

        :return: The smtp_server_port of this SmtpAccessDetails.  # noqa: E501
        :rtype: int
        """
        return self._smtp_server_port

    @smtp_server_port.setter
    def smtp_server_port(self, smtp_server_port):
        """Sets the smtp_server_port of this SmtpAccessDetails.

        SMTP server host port  # noqa: E501

        :param smtp_server_port: The smtp_server_port of this SmtpAccessDetails.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and smtp_server_port is None:  # noqa: E501
            raise ValueError("Invalid value for `smtp_server_port`, must not be `None`")  # noqa: E501

        self._smtp_server_port = smtp_server_port

    @property
    def smtp_username(self):
        """Gets the smtp_username of this SmtpAccessDetails.  # noqa: E501

        SMTP username for login  # noqa: E501

        :return: The smtp_username of this SmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._smtp_username

    @smtp_username.setter
    def smtp_username(self, smtp_username):
        """Sets the smtp_username of this SmtpAccessDetails.

        SMTP username for login  # noqa: E501

        :param smtp_username: The smtp_username of this SmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and smtp_username is None:  # noqa: E501
            raise ValueError("Invalid value for `smtp_username`, must not be `None`")  # noqa: E501

        self._smtp_username = smtp_username

    @property
    def smtp_password(self):
        """Gets the smtp_password of this SmtpAccessDetails.  # noqa: E501

        SMTP password for login  # noqa: E501

        :return: The smtp_password of this SmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._smtp_password

    @smtp_password.setter
    def smtp_password(self, smtp_password):
        """Sets the smtp_password of this SmtpAccessDetails.

        SMTP password for login  # noqa: E501

        :param smtp_password: The smtp_password of this SmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and smtp_password is None:  # noqa: E501
            raise ValueError("Invalid value for `smtp_password`, must not be `None`")  # noqa: E501

        self._smtp_password = smtp_password

    @property
    def mail_from_domain(self):
        """Gets the mail_from_domain of this SmtpAccessDetails.  # noqa: E501

        Mail from domain or SMTP HELO value  # noqa: E501

        :return: The mail_from_domain of this SmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._mail_from_domain

    @mail_from_domain.setter
    def mail_from_domain(self, mail_from_domain):
        """Sets the mail_from_domain of this SmtpAccessDetails.

        Mail from domain or SMTP HELO value  # noqa: E501

        :param mail_from_domain: The mail_from_domain of this SmtpAccessDetails.  # noqa: E501
        :type: str
        """

        self._mail_from_domain = mail_from_domain

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SmtpAccessDetails):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SmtpAccessDetails):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/sms_reply_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SmsReplyOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'body': 'str'
    }

    attribute_map = {
        'body': 'body'
    }

    def __init__(self, body=None, local_vars_configuration=None):  # noqa: E501
        """SmsReplyOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._body = None
        self.discriminator = None

        self.body = body

    @property
    def body(self):
        """Gets the body of this SmsReplyOptions.  # noqa: E501


        :return: The body of this SmsReplyOptions.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this SmsReplyOptions.


        :param body: The body of this SmsReplyOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and body is None:  # noqa: E501
            raise ValueError("Invalid value for `body`, must not be `None`")  # noqa: E501

        self._body = body

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SmsReplyOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SmsReplyOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/sms_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SmsProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'body': 'str',
        'created_at': 'datetime',
        'user_id': 'str',
        'phone_number': 'str',
        'from_number': 'str',
        'read': 'bool',
        'id': 'str'
    }

    attribute_map = {
        'body': 'body',
        'created_at': 'createdAt',
        'user_id': 'userId',
        'phone_number': 'phoneNumber',
        'from_number': 'fromNumber',
        'read': 'read',
        'id': 'id'
    }

    def __init__(self, body=None, created_at=None, user_id=None, phone_number=None, from_number=None, read=None, id=None, local_vars_configuration=None):  # noqa: E501
        """SmsProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._body = None
        self._created_at = None
        self._user_id = None
        self._phone_number = None
        self._from_number = None
        self._read = None
        self._id = None
        self.discriminator = None

        self.body = body
        self.created_at = created_at
        self.user_id = user_id
        self.phone_number = phone_number
        self.from_number = from_number
        self.read = read
        self.id = id

    @property
    def body(self):
        """Gets the body of this SmsProjection.  # noqa: E501


        :return: The body of this SmsProjection.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this SmsProjection.


        :param body: The body of this SmsProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and body is None:  # noqa: E501
            raise ValueError("Invalid value for `body`, must not be `None`")  # noqa: E501

        self._body = body

    @property
    def created_at(self):
        """Gets the created_at of this SmsProjection.  # noqa: E501


        :return: The created_at of this SmsProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this SmsProjection.


        :param created_at: The created_at of this SmsProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def user_id(self):
        """Gets the user_id of this SmsProjection.  # noqa: E501


        :return: The user_id of this SmsProjection.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this SmsProjection.


        :param user_id: The user_id of this SmsProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def phone_number(self):
        """Gets the phone_number of this SmsProjection.  # noqa: E501


        :return: The phone_number of this SmsProjection.  # noqa: E501
        :rtype: str
        """
        return self._phone_number

    @phone_number.setter
    def phone_number(self, phone_number):
        """Sets the phone_number of this SmsProjection.


        :param phone_number: The phone_number of this SmsProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and phone_number is None:  # noqa: E501
            raise ValueError("Invalid value for `phone_number`, must not be `None`")  # noqa: E501

        self._phone_number = phone_number

    @property
    def from_number(self):
        """Gets the from_number of this SmsProjection.  # noqa: E501


        :return: The from_number of this SmsProjection.  # noqa: E501
        :rtype: str
        """
        return self._from_number

    @from_number.setter
    def from_number(self, from_number):
        """Sets the from_number of this SmsProjection.


        :param from_number: The from_number of this SmsProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and from_number is None:  # noqa: E501
            raise ValueError("Invalid value for `from_number`, must not be `None`")  # noqa: E501

        self._from_number = from_number

    @property
    def read(self):
        """Gets the read of this SmsProjection.  # noqa: E501


        :return: The read of this SmsProjection.  # noqa: E501
        :rtype: bool
        """
        return self._read

    @read.setter
    def read(self, read):
        """Sets the read of this SmsProjection.


        :param read: The read of this SmsProjection.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and read is None:  # noqa: E501
            raise ValueError("Invalid value for `read`, must not be `None`")  # noqa: E501

        self._read = read

    @property
    def id(self):
        """Gets the id of this SmsProjection.  # noqa: E501


        :return: The id of this SmsProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this SmsProjection.


        :param id: The id of this SmsProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SmsProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SmsProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/sms_preview.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SmsPreview(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'body': 'str',
        'phone_number': 'str',
        'from_number': 'str',
        'created_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'body': 'body',
        'phone_number': 'phoneNumber',
        'from_number': 'fromNumber',
        'created_at': 'createdAt'
    }

    def __init__(self, id=None, user_id=None, body=None, phone_number=None, from_number=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """SmsPreview - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._body = None
        self._phone_number = None
        self._from_number = None
        self._created_at = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        self.body = body
        self.phone_number = phone_number
        self.from_number = from_number
        self.created_at = created_at

    @property
    def id(self):
        """Gets the id of this SmsPreview.  # noqa: E501


        :return: The id of this SmsPreview.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this SmsPreview.


        :param id: The id of this SmsPreview.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this SmsPreview.  # noqa: E501


        :return: The user_id of this SmsPreview.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this SmsPreview.


        :param user_id: The user_id of this SmsPreview.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def body(self):
        """Gets the body of this SmsPreview.  # noqa: E501


        :return: The body of this SmsPreview.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this SmsPreview.


        :param body: The body of this SmsPreview.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and body is None:  # noqa: E501
            raise ValueError("Invalid value for `body`, must not be `None`")  # noqa: E501

        self._body = body

    @property
    def phone_number(self):
        """Gets the phone_number of this SmsPreview.  # noqa: E501


        :return: The phone_number of this SmsPreview.  # noqa: E501
        :rtype: str
        """
        return self._phone_number

    @phone_number.setter
    def phone_number(self, phone_number):
        """Sets the phone_number of this SmsPreview.


        :param phone_number: The phone_number of this SmsPreview.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and phone_number is None:  # noqa: E501
            raise ValueError("Invalid value for `phone_number`, must not be `None`")  # noqa: E501

        self._phone_number = phone_number

    @property
    def from_number(self):
        """Gets the from_number of this SmsPreview.  # noqa: E501


        :return: The from_number of this SmsPreview.  # noqa: E501
        :rtype: str
        """
        return self._from_number

    @from_number.setter
    def from_number(self, from_number):
        """Sets the from_number of this SmsPreview.


        :param from_number: The from_number of this SmsPreview.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and from_number is None:  # noqa: E501
            raise ValueError("Invalid value for `from_number`, must not be `None`")  # noqa: E501

        self._from_number = from_number

    @property
    def created_at(self):
        """Gets the created_at of this SmsPreview.  # noqa: E501


        :return: The created_at of this SmsPreview.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this SmsPreview.


        :param created_at: The created_at of this SmsPreview.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SmsPreview):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SmsPreview):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/sms_match_option.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SmsMatchOption(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'field': 'str',
        'should': 'str',
        'value': 'str'
    }

    attribute_map = {
        'field': 'field',
        'should': 'should',
        'value': 'value'
    }

    def __init__(self, field=None, should=None, value=None, local_vars_configuration=None):  # noqa: E501
        """SmsMatchOption - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._field = None
        self._should = None
        self._value = None
        self.discriminator = None

        self.field = field
        self.should = should
        self.value = value

    @property
    def field(self):
        """Gets the field of this SmsMatchOption.  # noqa: E501

        Fields of an SMS object that can be used to filter results  # noqa: E501

        :return: The field of this SmsMatchOption.  # noqa: E501
        :rtype: str
        """
        return self._field

    @field.setter
    def field(self, field):
        """Sets the field of this SmsMatchOption.

        Fields of an SMS object that can be used to filter results  # noqa: E501

        :param field: The field of this SmsMatchOption.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and field is None:  # noqa: E501
            raise ValueError("Invalid value for `field`, must not be `None`")  # noqa: E501
        allowed_values = ["BODY", "FROM"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and field not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `field` ({0}), must be one of {1}"  # noqa: E501
                .format(field, allowed_values)
            )

        self._field = field

    @property
    def should(self):
        """Gets the should of this SmsMatchOption.  # noqa: E501

        How the value of the email field specified should be compared to the value given in the match options.  # noqa: E501

        :return: The should of this SmsMatchOption.  # noqa: E501
        :rtype: str
        """
        return self._should

    @should.setter
    def should(self, should):
        """Sets the should of this SmsMatchOption.

        How the value of the email field specified should be compared to the value given in the match options.  # noqa: E501

        :param should: The should of this SmsMatchOption.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and should is None:  # noqa: E501
            raise ValueError("Invalid value for `should`, must not be `None`")  # noqa: E501
        allowed_values = ["MATCH", "CONTAIN", "EQUAL"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and should not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `should` ({0}), must be one of {1}"  # noqa: E501
                .format(should, allowed_values)
            )

        self._should = should

    @property
    def value(self):
        """Gets the value of this SmsMatchOption.  # noqa: E501

        The value you wish to compare with the value of the field specified using the `should` value passed. For example `BODY` should `CONTAIN` a value passed.  # noqa: E501

        :return: The value of this SmsMatchOption.  # noqa: E501
        :rtype: str
        """
        return self._value

    @value.setter
    def value(self, value):
        """Sets the value of this SmsMatchOption.

        The value you wish to compare with the value of the field specified using the `should` value passed. For example `BODY` should `CONTAIN` a value passed.  # noqa: E501

        :param value: The value of this SmsMatchOption.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and value is None:  # noqa: E501
            raise ValueError("Invalid value for `value`, must not be `None`")  # noqa: E501

        self._value = value

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SmsMatchOption):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SmsMatchOption):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/sms_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SmsDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'phone_number': 'str',
        'from_number': 'str',
        'body': 'str',
        'read': 'bool',
        'created_at': 'datetime',
        'updated_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'phone_number': 'phoneNumber',
        'from_number': 'fromNumber',
        'body': 'body',
        'read': 'read',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt'
    }

    def __init__(self, id=None, user_id=None, phone_number=None, from_number=None, body=None, read=None, created_at=None, updated_at=None, local_vars_configuration=None):  # noqa: E501
        """SmsDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._phone_number = None
        self._from_number = None
        self._body = None
        self._read = None
        self._created_at = None
        self._updated_at = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        self.phone_number = phone_number
        self.from_number = from_number
        self.body = body
        self.read = read
        self.created_at = created_at
        self.updated_at = updated_at

    @property
    def id(self):
        """Gets the id of this SmsDto.  # noqa: E501


        :return: The id of this SmsDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this SmsDto.


        :param id: The id of this SmsDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this SmsDto.  # noqa: E501


        :return: The user_id of this SmsDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this SmsDto.


        :param user_id: The user_id of this SmsDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def phone_number(self):
        """Gets the phone_number of this SmsDto.  # noqa: E501


        :return: The phone_number of this SmsDto.  # noqa: E501
        :rtype: str
        """
        return self._phone_number

    @phone_number.setter
    def phone_number(self, phone_number):
        """Sets the phone_number of this SmsDto.


        :param phone_number: The phone_number of this SmsDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and phone_number is None:  # noqa: E501
            raise ValueError("Invalid value for `phone_number`, must not be `None`")  # noqa: E501

        self._phone_number = phone_number

    @property
    def from_number(self):
        """Gets the from_number of this SmsDto.  # noqa: E501


        :return: The from_number of this SmsDto.  # noqa: E501
        :rtype: str
        """
        return self._from_number

    @from_number.setter
    def from_number(self, from_number):
        """Sets the from_number of this SmsDto.


        :param from_number: The from_number of this SmsDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and from_number is None:  # noqa: E501
            raise ValueError("Invalid value for `from_number`, must not be `None`")  # noqa: E501

        self._from_number = from_number

    @property
    def body(self):
        """Gets the body of this SmsDto.  # noqa: E501


        :return: The body of this SmsDto.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this SmsDto.


        :param body: The body of this SmsDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and body is None:  # noqa: E501
            raise ValueError("Invalid value for `body`, must not be `None`")  # noqa: E501

        self._body = body

    @property
    def read(self):
        """Gets the read of this SmsDto.  # noqa: E501


        :return: The read of this SmsDto.  # noqa: E501
        :rtype: bool
        """
        return self._read

    @read.setter
    def read(self, read):
        """Sets the read of this SmsDto.


        :param read: The read of this SmsDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and read is None:  # noqa: E501
            raise ValueError("Invalid value for `read`, must not be `None`")  # noqa: E501

        self._read = read

    @property
    def created_at(self):
        """Gets the created_at of this SmsDto.  # noqa: E501


        :return: The created_at of this SmsDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this SmsDto.


        :param created_at: The created_at of this SmsDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this SmsDto.  # noqa: E501


        :return: The updated_at of this SmsDto.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this SmsDto.


        :param updated_at: The updated_at of this SmsDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SmsDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SmsDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/simple_send_email_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SimpleSendEmailOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'sender_id': 'str',
        'to': 'str',
        'body': 'str',
        'subject': 'str'
    }

    attribute_map = {
        'sender_id': 'senderId',
        'to': 'to',
        'body': 'body',
        'subject': 'subject'
    }

    def __init__(self, sender_id=None, to=None, body=None, subject=None, local_vars_configuration=None):  # noqa: E501
        """SimpleSendEmailOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._sender_id = None
        self._to = None
        self._body = None
        self._subject = None
        self.discriminator = None

        self.sender_id = sender_id
        self.to = to
        self.body = body
        self.subject = subject

    @property
    def sender_id(self):
        """Gets the sender_id of this SimpleSendEmailOptions.  # noqa: E501

        ID of inbox to send from. If null an inbox will be created for sending  # noqa: E501

        :return: The sender_id of this SimpleSendEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._sender_id

    @sender_id.setter
    def sender_id(self, sender_id):
        """Sets the sender_id of this SimpleSendEmailOptions.

        ID of inbox to send from. If null an inbox will be created for sending  # noqa: E501

        :param sender_id: The sender_id of this SimpleSendEmailOptions.  # noqa: E501
        :type: str
        """

        self._sender_id = sender_id

    @property
    def to(self):
        """Gets the to of this SimpleSendEmailOptions.  # noqa: E501

        Email address to send to  # noqa: E501

        :return: The to of this SimpleSendEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._to

    @to.setter
    def to(self, to):
        """Sets the to of this SimpleSendEmailOptions.

        Email address to send to  # noqa: E501

        :param to: The to of this SimpleSendEmailOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and to is None:  # noqa: E501
            raise ValueError("Invalid value for `to`, must not be `None`")  # noqa: E501

        self._to = to

    @property
    def body(self):
        """Gets the body of this SimpleSendEmailOptions.  # noqa: E501

        Body of the email message. Supports HTML  # noqa: E501

        :return: The body of this SimpleSendEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this SimpleSendEmailOptions.

        Body of the email message. Supports HTML  # noqa: E501

        :param body: The body of this SimpleSendEmailOptions.  # noqa: E501
        :type: str
        """

        self._body = body

    @property
    def subject(self):
        """Gets the subject of this SimpleSendEmailOptions.  # noqa: E501

        Subject line of the email  # noqa: E501

        :return: The subject of this SimpleSendEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this SimpleSendEmailOptions.

        Subject line of the email  # noqa: E501

        :param subject: The subject of this SimpleSendEmailOptions.  # noqa: E501
        :type: str
        """

        self._subject = subject

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SimpleSendEmailOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SimpleSendEmailOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/set_inbox_favourited_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SetInboxFavouritedOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'state': 'bool'
    }

    attribute_map = {
        'state': 'state'
    }

    def __init__(self, state=None, local_vars_configuration=None):  # noqa: E501
        """SetInboxFavouritedOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._state = None
        self.discriminator = None

        self.state = state

    @property
    def state(self):
        """Gets the state of this SetInboxFavouritedOptions.  # noqa: E501

        Is the inbox a favorite. Marking an inbox as a favorite is typically done in the dashboard for quick access or filtering  # noqa: E501

        :return: The state of this SetInboxFavouritedOptions.  # noqa: E501
        :rtype: bool
        """
        return self._state

    @state.setter
    def state(self, state):
        """Sets the state of this SetInboxFavouritedOptions.

        Is the inbox a favorite. Marking an inbox as a favorite is typically done in the dashboard for quick access or filtering  # noqa: E501

        :param state: The state of this SetInboxFavouritedOptions.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and state is None:  # noqa: E501
            raise ValueError("Invalid value for `state`, must not be `None`")  # noqa: E501

        self._state = state

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SetInboxFavouritedOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SetInboxFavouritedOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/server_endpoints.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ServerEndpoints(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'host': 'str',
        'port': 'int',
        'tls': 'bool',
        'alt_ports': 'list[int]'
    }

    attribute_map = {
        'host': 'host',
        'port': 'port',
        'tls': 'tls',
        'alt_ports': 'altPorts'
    }

    def __init__(self, host=None, port=None, tls=None, alt_ports=None, local_vars_configuration=None):  # noqa: E501
        """ServerEndpoints - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._host = None
        self._port = None
        self._tls = None
        self._alt_ports = None
        self.discriminator = None

        self.host = host
        self.port = port
        self.tls = tls
        self.alt_ports = alt_ports

    @property
    def host(self):
        """Gets the host of this ServerEndpoints.  # noqa: E501


        :return: The host of this ServerEndpoints.  # noqa: E501
        :rtype: str
        """
        return self._host

    @host.setter
    def host(self, host):
        """Sets the host of this ServerEndpoints.


        :param host: The host of this ServerEndpoints.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and host is None:  # noqa: E501
            raise ValueError("Invalid value for `host`, must not be `None`")  # noqa: E501

        self._host = host

    @property
    def port(self):
        """Gets the port of this ServerEndpoints.  # noqa: E501


        :return: The port of this ServerEndpoints.  # noqa: E501
        :rtype: int
        """
        return self._port

    @port.setter
    def port(self, port):
        """Sets the port of this ServerEndpoints.


        :param port: The port of this ServerEndpoints.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and port is None:  # noqa: E501
            raise ValueError("Invalid value for `port`, must not be `None`")  # noqa: E501

        self._port = port

    @property
    def tls(self):
        """Gets the tls of this ServerEndpoints.  # noqa: E501


        :return: The tls of this ServerEndpoints.  # noqa: E501
        :rtype: bool
        """
        return self._tls

    @tls.setter
    def tls(self, tls):
        """Sets the tls of this ServerEndpoints.


        :param tls: The tls of this ServerEndpoints.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and tls is None:  # noqa: E501
            raise ValueError("Invalid value for `tls`, must not be `None`")  # noqa: E501

        self._tls = tls

    @property
    def alt_ports(self):
        """Gets the alt_ports of this ServerEndpoints.  # noqa: E501


        :return: The alt_ports of this ServerEndpoints.  # noqa: E501
        :rtype: list[int]
        """
        return self._alt_ports

    @alt_ports.setter
    def alt_ports(self, alt_ports):
        """Sets the alt_ports of this ServerEndpoints.


        :param alt_ports: The alt_ports of this ServerEndpoints.  # noqa: E501
        :type: list[int]
        """
        if self.local_vars_configuration.client_side_validation and alt_ports is None:  # noqa: E501
            raise ValueError("Invalid value for `alt_ports`, must not be `None`")  # noqa: E501

        self._alt_ports = alt_ports

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ServerEndpoints):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ServerEndpoints):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/sent_sms_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SentSmsDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'phone_number': 'str',
        'from_number': 'str',
        'to_number': 'str',
        'body': 'str',
        'sid': 'str',
        'reply_to_sid': 'str',
        'reply_to_id': 'str',
        'created_at': 'datetime',
        'updated_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'phone_number': 'phoneNumber',
        'from_number': 'fromNumber',
        'to_number': 'toNumber',
        'body': 'body',
        'sid': 'sid',
        'reply_to_sid': 'replyToSid',
        'reply_to_id': 'replyToId',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt'
    }

    def __init__(self, id=None, user_id=None, phone_number=None, from_number=None, to_number=None, body=None, sid=None, reply_to_sid=None, reply_to_id=None, created_at=None, updated_at=None, local_vars_configuration=None):  # noqa: E501
        """SentSmsDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._phone_number = None
        self._from_number = None
        self._to_number = None
        self._body = None
        self._sid = None
        self._reply_to_sid = None
        self._reply_to_id = None
        self._created_at = None
        self._updated_at = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        self.phone_number = phone_number
        self.from_number = from_number
        self.to_number = to_number
        self.body = body
        self.sid = sid
        self.reply_to_sid = reply_to_sid
        self.reply_to_id = reply_to_id
        self.created_at = created_at
        self.updated_at = updated_at

    @property
    def id(self):
        """Gets the id of this SentSmsDto.  # noqa: E501


        :return: The id of this SentSmsDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this SentSmsDto.


        :param id: The id of this SentSmsDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this SentSmsDto.  # noqa: E501


        :return: The user_id of this SentSmsDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this SentSmsDto.


        :param user_id: The user_id of this SentSmsDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def phone_number(self):
        """Gets the phone_number of this SentSmsDto.  # noqa: E501


        :return: The phone_number of this SentSmsDto.  # noqa: E501
        :rtype: str
        """
        return self._phone_number

    @phone_number.setter
    def phone_number(self, phone_number):
        """Sets the phone_number of this SentSmsDto.


        :param phone_number: The phone_number of this SentSmsDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and phone_number is None:  # noqa: E501
            raise ValueError("Invalid value for `phone_number`, must not be `None`")  # noqa: E501

        self._phone_number = phone_number

    @property
    def from_number(self):
        """Gets the from_number of this SentSmsDto.  # noqa: E501


        :return: The from_number of this SentSmsDto.  # noqa: E501
        :rtype: str
        """
        return self._from_number

    @from_number.setter
    def from_number(self, from_number):
        """Sets the from_number of this SentSmsDto.


        :param from_number: The from_number of this SentSmsDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and from_number is None:  # noqa: E501
            raise ValueError("Invalid value for `from_number`, must not be `None`")  # noqa: E501

        self._from_number = from_number

    @property
    def to_number(self):
        """Gets the to_number of this SentSmsDto.  # noqa: E501


        :return: The to_number of this SentSmsDto.  # noqa: E501
        :rtype: str
        """
        return self._to_number

    @to_number.setter
    def to_number(self, to_number):
        """Sets the to_number of this SentSmsDto.


        :param to_number: The to_number of this SentSmsDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and to_number is None:  # noqa: E501
            raise ValueError("Invalid value for `to_number`, must not be `None`")  # noqa: E501

        self._to_number = to_number

    @property
    def body(self):
        """Gets the body of this SentSmsDto.  # noqa: E501


        :return: The body of this SentSmsDto.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this SentSmsDto.


        :param body: The body of this SentSmsDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and body is None:  # noqa: E501
            raise ValueError("Invalid value for `body`, must not be `None`")  # noqa: E501

        self._body = body

    @property
    def sid(self):
        """Gets the sid of this SentSmsDto.  # noqa: E501


        :return: The sid of this SentSmsDto.  # noqa: E501
        :rtype: str
        """
        return self._sid

    @sid.setter
    def sid(self, sid):
        """Sets the sid of this SentSmsDto.


        :param sid: The sid of this SentSmsDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and sid is None:  # noqa: E501
            raise ValueError("Invalid value for `sid`, must not be `None`")  # noqa: E501

        self._sid = sid

    @property
    def reply_to_sid(self):
        """Gets the reply_to_sid of this SentSmsDto.  # noqa: E501


        :return: The reply_to_sid of this SentSmsDto.  # noqa: E501
        :rtype: str
        """
        return self._reply_to_sid

    @reply_to_sid.setter
    def reply_to_sid(self, reply_to_sid):
        """Sets the reply_to_sid of this SentSmsDto.


        :param reply_to_sid: The reply_to_sid of this SentSmsDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and reply_to_sid is None:  # noqa: E501
            raise ValueError("Invalid value for `reply_to_sid`, must not be `None`")  # noqa: E501

        self._reply_to_sid = reply_to_sid

    @property
    def reply_to_id(self):
        """Gets the reply_to_id of this SentSmsDto.  # noqa: E501


        :return: The reply_to_id of this SentSmsDto.  # noqa: E501
        :rtype: str
        """
        return self._reply_to_id

    @reply_to_id.setter
    def reply_to_id(self, reply_to_id):
        """Sets the reply_to_id of this SentSmsDto.


        :param reply_to_id: The reply_to_id of this SentSmsDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and reply_to_id is None:  # noqa: E501
            raise ValueError("Invalid value for `reply_to_id`, must not be `None`")  # noqa: E501

        self._reply_to_id = reply_to_id

    @property
    def created_at(self):
        """Gets the created_at of this SentSmsDto.  # noqa: E501


        :return: The created_at of this SentSmsDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this SentSmsDto.


        :param created_at: The created_at of this SentSmsDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this SentSmsDto.  # noqa: E501


        :return: The updated_at of this SentSmsDto.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this SentSmsDto.


        :param updated_at: The updated_at of this SentSmsDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SentSmsDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SentSmsDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/sent_email_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SentEmailProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'id': 'str',
        '_from': 'str',
        'subject': 'str',
        'attachments': 'list[str]',
        'inbox_id': 'str',
        'user_id': 'str',
        'to': 'list[str]',
        'bcc': 'list[str]',
        'cc': 'list[str]',
        'body_md5_hash': 'str',
        'virtual_send': 'bool'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'id': 'id',
        '_from': 'from',
        'subject': 'subject',
        'attachments': 'attachments',
        'inbox_id': 'inboxId',
        'user_id': 'userId',
        'to': 'to',
        'bcc': 'bcc',
        'cc': 'cc',
        'body_md5_hash': 'bodyMD5Hash',
        'virtual_send': 'virtualSend'
    }

    def __init__(self, created_at=None, id=None, _from=None, subject=None, attachments=None, inbox_id=None, user_id=None, to=None, bcc=None, cc=None, body_md5_hash=None, virtual_send=None, local_vars_configuration=None):  # noqa: E501
        """SentEmailProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._id = None
        self.__from = None
        self._subject = None
        self._attachments = None
        self._inbox_id = None
        self._user_id = None
        self._to = None
        self._bcc = None
        self._cc = None
        self._body_md5_hash = None
        self._virtual_send = None
        self.discriminator = None

        self.created_at = created_at
        self.id = id
        if _from is not None:
            self._from = _from
        if subject is not None:
            self.subject = subject
        self.attachments = attachments
        self.inbox_id = inbox_id
        self.user_id = user_id
        self.to = to
        self.bcc = bcc
        self.cc = cc
        if body_md5_hash is not None:
            self.body_md5_hash = body_md5_hash
        self.virtual_send = virtual_send

    @property
    def created_at(self):
        """Gets the created_at of this SentEmailProjection.  # noqa: E501


        :return: The created_at of this SentEmailProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this SentEmailProjection.


        :param created_at: The created_at of this SentEmailProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def id(self):
        """Gets the id of this SentEmailProjection.  # noqa: E501


        :return: The id of this SentEmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this SentEmailProjection.


        :param id: The id of this SentEmailProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def _from(self):
        """Gets the _from of this SentEmailProjection.  # noqa: E501


        :return: The _from of this SentEmailProjection.  # noqa: E501
        :rtype: str
        """
        return self.__from

    @_from.setter
    def _from(self, _from):
        """Sets the _from of this SentEmailProjection.


        :param _from: The _from of this SentEmailProjection.  # noqa: E501
        :type: str
        """

        self.__from = _from

    @property
    def subject(self):
        """Gets the subject of this SentEmailProjection.  # noqa: E501


        :return: The subject of this SentEmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this SentEmailProjection.


        :param subject: The subject of this SentEmailProjection.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def attachments(self):
        """Gets the attachments of this SentEmailProjection.  # noqa: E501


        :return: The attachments of this SentEmailProjection.  # noqa: E501
        :rtype: list[str]
        """
        return self._attachments

    @attachments.setter
    def attachments(self, attachments):
        """Sets the attachments of this SentEmailProjection.


        :param attachments: The attachments of this SentEmailProjection.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and attachments is None:  # noqa: E501
            raise ValueError("Invalid value for `attachments`, must not be `None`")  # noqa: E501

        self._attachments = attachments

    @property
    def inbox_id(self):
        """Gets the inbox_id of this SentEmailProjection.  # noqa: E501


        :return: The inbox_id of this SentEmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this SentEmailProjection.


        :param inbox_id: The inbox_id of this SentEmailProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def user_id(self):
        """Gets the user_id of this SentEmailProjection.  # noqa: E501


        :return: The user_id of this SentEmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this SentEmailProjection.


        :param user_id: The user_id of this SentEmailProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def to(self):
        """Gets the to of this SentEmailProjection.  # noqa: E501


        :return: The to of this SentEmailProjection.  # noqa: E501
        :rtype: list[str]
        """
        return self._to

    @to.setter
    def to(self, to):
        """Sets the to of this SentEmailProjection.


        :param to: The to of this SentEmailProjection.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and to is None:  # noqa: E501
            raise ValueError("Invalid value for `to`, must not be `None`")  # noqa: E501

        self._to = to

    @property
    def bcc(self):
        """Gets the bcc of this SentEmailProjection.  # noqa: E501


        :return: The bcc of this SentEmailProjection.  # noqa: E501
        :rtype: list[str]
        """
        return self._bcc

    @bcc.setter
    def bcc(self, bcc):
        """Sets the bcc of this SentEmailProjection.


        :param bcc: The bcc of this SentEmailProjection.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and bcc is None:  # noqa: E501
            raise ValueError("Invalid value for `bcc`, must not be `None`")  # noqa: E501

        self._bcc = bcc

    @property
    def cc(self):
        """Gets the cc of this SentEmailProjection.  # noqa: E501


        :return: The cc of this SentEmailProjection.  # noqa: E501
        :rtype: list[str]
        """
        return self._cc

    @cc.setter
    def cc(self, cc):
        """Sets the cc of this SentEmailProjection.


        :param cc: The cc of this SentEmailProjection.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and cc is None:  # noqa: E501
            raise ValueError("Invalid value for `cc`, must not be `None`")  # noqa: E501

        self._cc = cc

    @property
    def body_md5_hash(self):
        """Gets the body_md5_hash of this SentEmailProjection.  # noqa: E501


        :return: The body_md5_hash of this SentEmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._body_md5_hash

    @body_md5_hash.setter
    def body_md5_hash(self, body_md5_hash):
        """Sets the body_md5_hash of this SentEmailProjection.


        :param body_md5_hash: The body_md5_hash of this SentEmailProjection.  # noqa: E501
        :type: str
        """

        self._body_md5_hash = body_md5_hash

    @property
    def virtual_send(self):
        """Gets the virtual_send of this SentEmailProjection.  # noqa: E501


        :return: The virtual_send of this SentEmailProjection.  # noqa: E501
        :rtype: bool
        """
        return self._virtual_send

    @virtual_send.setter
    def virtual_send(self, virtual_send):
        """Sets the virtual_send of this SentEmailProjection.


        :param virtual_send: The virtual_send of this SentEmailProjection.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and virtual_send is None:  # noqa: E501
            raise ValueError("Invalid value for `virtual_send`, must not be `None`")  # noqa: E501

        self._virtual_send = virtual_send

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SentEmailProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SentEmailProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/sent_email_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SentEmailDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'inbox_id': 'str',
        'domain_id': 'str',
        'to': 'list[str]',
        '_from': 'str',
        'reply_to': 'str',
        'cc': 'list[str]',
        'bcc': 'list[str]',
        'attachments': 'list[str]',
        'subject': 'str',
        'body_md5_hash': 'str',
        'body': 'str',
        'to_contacts': 'list[str]',
        'to_group': 'str',
        'charset': 'str',
        'is_html': 'bool',
        'sent_at': 'datetime',
        'pixel_ids': 'list[str]',
        'message_id': 'str',
        'message_ids': 'list[str]',
        'virtual_send': 'bool',
        'template_id': 'str',
        'template_variables': 'dict(str, object)',
        'headers': 'dict(str, str)',
        'html': 'bool'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'inbox_id': 'inboxId',
        'domain_id': 'domainId',
        'to': 'to',
        '_from': 'from',
        'reply_to': 'replyTo',
        'cc': 'cc',
        'bcc': 'bcc',
        'attachments': 'attachments',
        'subject': 'subject',
        'body_md5_hash': 'bodyMD5Hash',
        'body': 'body',
        'to_contacts': 'toContacts',
        'to_group': 'toGroup',
        'charset': 'charset',
        'is_html': 'isHTML',
        'sent_at': 'sentAt',
        'pixel_ids': 'pixelIds',
        'message_id': 'messageId',
        'message_ids': 'messageIds',
        'virtual_send': 'virtualSend',
        'template_id': 'templateId',
        'template_variables': 'templateVariables',
        'headers': 'headers',
        'html': 'html'
    }

    def __init__(self, id=None, user_id=None, inbox_id=None, domain_id=None, to=None, _from=None, reply_to=None, cc=None, bcc=None, attachments=None, subject=None, body_md5_hash=None, body=None, to_contacts=None, to_group=None, charset=None, is_html=None, sent_at=None, pixel_ids=None, message_id=None, message_ids=None, virtual_send=None, template_id=None, template_variables=None, headers=None, html=None, local_vars_configuration=None):  # noqa: E501
        """SentEmailDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._inbox_id = None
        self._domain_id = None
        self._to = None
        self.__from = None
        self._reply_to = None
        self._cc = None
        self._bcc = None
        self._attachments = None
        self._subject = None
        self._body_md5_hash = None
        self._body = None
        self._to_contacts = None
        self._to_group = None
        self._charset = None
        self._is_html = None
        self._sent_at = None
        self._pixel_ids = None
        self._message_id = None
        self._message_ids = None
        self._virtual_send = None
        self._template_id = None
        self._template_variables = None
        self._headers = None
        self._html = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        self.inbox_id = inbox_id
        self.domain_id = domain_id
        self.to = to
        self._from = _from
        self.reply_to = reply_to
        self.cc = cc
        self.bcc = bcc
        self.attachments = attachments
        self.subject = subject
        self.body_md5_hash = body_md5_hash
        self.body = body
        self.to_contacts = to_contacts
        self.to_group = to_group
        self.charset = charset
        self.is_html = is_html
        self.sent_at = sent_at
        self.pixel_ids = pixel_ids
        self.message_id = message_id
        self.message_ids = message_ids
        self.virtual_send = virtual_send
        self.template_id = template_id
        self.template_variables = template_variables
        self.headers = headers
        if html is not None:
            self.html = html

    @property
    def id(self):
        """Gets the id of this SentEmailDto.  # noqa: E501

        ID of sent email  # noqa: E501

        :return: The id of this SentEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this SentEmailDto.

        ID of sent email  # noqa: E501

        :param id: The id of this SentEmailDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this SentEmailDto.  # noqa: E501

        User ID  # noqa: E501

        :return: The user_id of this SentEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this SentEmailDto.

        User ID  # noqa: E501

        :param user_id: The user_id of this SentEmailDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def inbox_id(self):
        """Gets the inbox_id of this SentEmailDto.  # noqa: E501

        Inbox ID email was sent from  # noqa: E501

        :return: The inbox_id of this SentEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this SentEmailDto.

        Inbox ID email was sent from  # noqa: E501

        :param inbox_id: The inbox_id of this SentEmailDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def domain_id(self):
        """Gets the domain_id of this SentEmailDto.  # noqa: E501

        Domain ID  # noqa: E501

        :return: The domain_id of this SentEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._domain_id

    @domain_id.setter
    def domain_id(self, domain_id):
        """Sets the domain_id of this SentEmailDto.

        Domain ID  # noqa: E501

        :param domain_id: The domain_id of this SentEmailDto.  # noqa: E501
        :type: str
        """

        self._domain_id = domain_id

    @property
    def to(self):
        """Gets the to of this SentEmailDto.  # noqa: E501

        Recipients email was sent to  # noqa: E501

        :return: The to of this SentEmailDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._to

    @to.setter
    def to(self, to):
        """Sets the to of this SentEmailDto.

        Recipients email was sent to  # noqa: E501

        :param to: The to of this SentEmailDto.  # noqa: E501
        :type: list[str]
        """

        self._to = to

    @property
    def _from(self):
        """Gets the _from of this SentEmailDto.  # noqa: E501

        Sent from address  # noqa: E501

        :return: The _from of this SentEmailDto.  # noqa: E501
        :rtype: str
        """
        return self.__from

    @_from.setter
    def _from(self, _from):
        """Sets the _from of this SentEmailDto.

        Sent from address  # noqa: E501

        :param _from: The _from of this SentEmailDto.  # noqa: E501
        :type: str
        """

        self.__from = _from

    @property
    def reply_to(self):
        """Gets the reply_to of this SentEmailDto.  # noqa: E501


        :return: The reply_to of this SentEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._reply_to

    @reply_to.setter
    def reply_to(self, reply_to):
        """Sets the reply_to of this SentEmailDto.


        :param reply_to: The reply_to of this SentEmailDto.  # noqa: E501
        :type: str
        """

        self._reply_to = reply_to

    @property
    def cc(self):
        """Gets the cc of this SentEmailDto.  # noqa: E501


        :return: The cc of this SentEmailDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._cc

    @cc.setter
    def cc(self, cc):
        """Sets the cc of this SentEmailDto.


        :param cc: The cc of this SentEmailDto.  # noqa: E501
        :type: list[str]
        """

        self._cc = cc

    @property
    def bcc(self):
        """Gets the bcc of this SentEmailDto.  # noqa: E501


        :return: The bcc of this SentEmailDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._bcc

    @bcc.setter
    def bcc(self, bcc):
        """Sets the bcc of this SentEmailDto.


        :param bcc: The bcc of this SentEmailDto.  # noqa: E501
        :type: list[str]
        """

        self._bcc = bcc

    @property
    def attachments(self):
        """Gets the attachments of this SentEmailDto.  # noqa: E501

        Array of IDs of attachments that were sent with this email  # noqa: E501

        :return: The attachments of this SentEmailDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._attachments

    @attachments.setter
    def attachments(self, attachments):
        """Sets the attachments of this SentEmailDto.

        Array of IDs of attachments that were sent with this email  # noqa: E501

        :param attachments: The attachments of this SentEmailDto.  # noqa: E501
        :type: list[str]
        """

        self._attachments = attachments

    @property
    def subject(self):
        """Gets the subject of this SentEmailDto.  # noqa: E501


        :return: The subject of this SentEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this SentEmailDto.


        :param subject: The subject of this SentEmailDto.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def body_md5_hash(self):
        """Gets the body_md5_hash of this SentEmailDto.  # noqa: E501

        MD5 Hash  # noqa: E501

        :return: The body_md5_hash of this SentEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._body_md5_hash

    @body_md5_hash.setter
    def body_md5_hash(self, body_md5_hash):
        """Sets the body_md5_hash of this SentEmailDto.

        MD5 Hash  # noqa: E501

        :param body_md5_hash: The body_md5_hash of this SentEmailDto.  # noqa: E501
        :type: str
        """

        self._body_md5_hash = body_md5_hash

    @property
    def body(self):
        """Gets the body of this SentEmailDto.  # noqa: E501

        Sent email body  # noqa: E501

        :return: The body of this SentEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this SentEmailDto.

        Sent email body  # noqa: E501

        :param body: The body of this SentEmailDto.  # noqa: E501
        :type: str
        """

        self._body = body

    @property
    def to_contacts(self):
        """Gets the to_contacts of this SentEmailDto.  # noqa: E501


        :return: The to_contacts of this SentEmailDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._to_contacts

    @to_contacts.setter
    def to_contacts(self, to_contacts):
        """Sets the to_contacts of this SentEmailDto.


        :param to_contacts: The to_contacts of this SentEmailDto.  # noqa: E501
        :type: list[str]
        """

        self._to_contacts = to_contacts

    @property
    def to_group(self):
        """Gets the to_group of this SentEmailDto.  # noqa: E501


        :return: The to_group of this SentEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._to_group

    @to_group.setter
    def to_group(self, to_group):
        """Sets the to_group of this SentEmailDto.


        :param to_group: The to_group of this SentEmailDto.  # noqa: E501
        :type: str
        """

        self._to_group = to_group

    @property
    def charset(self):
        """Gets the charset of this SentEmailDto.  # noqa: E501


        :return: The charset of this SentEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._charset

    @charset.setter
    def charset(self, charset):
        """Sets the charset of this SentEmailDto.


        :param charset: The charset of this SentEmailDto.  # noqa: E501
        :type: str
        """

        self._charset = charset

    @property
    def is_html(self):
        """Gets the is_html of this SentEmailDto.  # noqa: E501


        :return: The is_html of this SentEmailDto.  # noqa: E501
        :rtype: bool
        """
        return self._is_html

    @is_html.setter
    def is_html(self, is_html):
        """Sets the is_html of this SentEmailDto.


        :param is_html: The is_html of this SentEmailDto.  # noqa: E501
        :type: bool
        """

        self._is_html = is_html

    @property
    def sent_at(self):
        """Gets the sent_at of this SentEmailDto.  # noqa: E501


        :return: The sent_at of this SentEmailDto.  # noqa: E501
        :rtype: datetime
        """
        return self._sent_at

    @sent_at.setter
    def sent_at(self, sent_at):
        """Sets the sent_at of this SentEmailDto.


        :param sent_at: The sent_at of this SentEmailDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and sent_at is None:  # noqa: E501
            raise ValueError("Invalid value for `sent_at`, must not be `None`")  # noqa: E501

        self._sent_at = sent_at

    @property
    def pixel_ids(self):
        """Gets the pixel_ids of this SentEmailDto.  # noqa: E501


        :return: The pixel_ids of this SentEmailDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._pixel_ids

    @pixel_ids.setter
    def pixel_ids(self, pixel_ids):
        """Sets the pixel_ids of this SentEmailDto.


        :param pixel_ids: The pixel_ids of this SentEmailDto.  # noqa: E501
        :type: list[str]
        """

        self._pixel_ids = pixel_ids

    @property
    def message_id(self):
        """Gets the message_id of this SentEmailDto.  # noqa: E501


        :return: The message_id of this SentEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._message_id

    @message_id.setter
    def message_id(self, message_id):
        """Sets the message_id of this SentEmailDto.


        :param message_id: The message_id of this SentEmailDto.  # noqa: E501
        :type: str
        """

        self._message_id = message_id

    @property
    def message_ids(self):
        """Gets the message_ids of this SentEmailDto.  # noqa: E501


        :return: The message_ids of this SentEmailDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._message_ids

    @message_ids.setter
    def message_ids(self, message_ids):
        """Sets the message_ids of this SentEmailDto.


        :param message_ids: The message_ids of this SentEmailDto.  # noqa: E501
        :type: list[str]
        """

        self._message_ids = message_ids

    @property
    def virtual_send(self):
        """Gets the virtual_send of this SentEmailDto.  # noqa: E501


        :return: The virtual_send of this SentEmailDto.  # noqa: E501
        :rtype: bool
        """
        return self._virtual_send

    @virtual_send.setter
    def virtual_send(self, virtual_send):
        """Sets the virtual_send of this SentEmailDto.


        :param virtual_send: The virtual_send of this SentEmailDto.  # noqa: E501
        :type: bool
        """

        self._virtual_send = virtual_send

    @property
    def template_id(self):
        """Gets the template_id of this SentEmailDto.  # noqa: E501


        :return: The template_id of this SentEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._template_id

    @template_id.setter
    def template_id(self, template_id):
        """Sets the template_id of this SentEmailDto.


        :param template_id: The template_id of this SentEmailDto.  # noqa: E501
        :type: str
        """

        self._template_id = template_id

    @property
    def template_variables(self):
        """Gets the template_variables of this SentEmailDto.  # noqa: E501


        :return: The template_variables of this SentEmailDto.  # noqa: E501
        :rtype: dict(str, object)
        """
        return self._template_variables

    @template_variables.setter
    def template_variables(self, template_variables):
        """Sets the template_variables of this SentEmailDto.


        :param template_variables: The template_variables of this SentEmailDto.  # noqa: E501
        :type: dict(str, object)
        """

        self._template_variables = template_variables

    @property
    def headers(self):
        """Gets the headers of this SentEmailDto.  # noqa: E501


        :return: The headers of this SentEmailDto.  # noqa: E501
        :rtype: dict(str, str)
        """
        return self._headers

    @headers.setter
    def headers(self, headers):
        """Sets the headers of this SentEmailDto.


        :param headers: The headers of this SentEmailDto.  # noqa: E501
        :type: dict(str, str)
        """

        self._headers = headers

    @property
    def html(self):
        """Gets the html of this SentEmailDto.  # noqa: E501


        :return: The html of this SentEmailDto.  # noqa: E501
        :rtype: bool
        """
        return self._html

    @html.setter
    def html(self, html):
        """Sets the html of this SentEmailDto.


        :param html: The html of this SentEmailDto.  # noqa: E501
        :type: bool
        """

        self._html = html

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SentEmailDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SentEmailDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/sender.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class Sender(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'raw_value': 'str',
        'email_address': 'str',
        'name': 'str'
    }

    attribute_map = {
        'raw_value': 'rawValue',
        'email_address': 'emailAddress',
        'name': 'name'
    }

    def __init__(self, raw_value=None, email_address=None, name=None, local_vars_configuration=None):  # noqa: E501
        """Sender - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._raw_value = None
        self._email_address = None
        self._name = None
        self.discriminator = None

        self.raw_value = raw_value
        self.email_address = email_address
        if name is not None:
            self.name = name

    @property
    def raw_value(self):
        """Gets the raw_value of this Sender.  # noqa: E501


        :return: The raw_value of this Sender.  # noqa: E501
        :rtype: str
        """
        return self._raw_value

    @raw_value.setter
    def raw_value(self, raw_value):
        """Sets the raw_value of this Sender.


        :param raw_value: The raw_value of this Sender.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and raw_value is None:  # noqa: E501
            raise ValueError("Invalid value for `raw_value`, must not be `None`")  # noqa: E501

        self._raw_value = raw_value

    @property
    def email_address(self):
        """Gets the email_address of this Sender.  # noqa: E501


        :return: The email_address of this Sender.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this Sender.


        :param email_address: The email_address of this Sender.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    @property
    def name(self):
        """Gets the name of this Sender.  # noqa: E501


        :return: The name of this Sender.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this Sender.


        :param name: The name of this Sender.  # noqa: E501
        :type: str
        """

        self._name = name

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, Sender):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, Sender):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/send_with_queue_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SendWithQueueResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'subject': 'str',
        'inbox_id': 'str',
        'header_id': 'str',
        'delivered': 'bool',
        'exception_name': 'str',
        'message': 'str',
        'created_at': 'datetime',
        'updated_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'subject': 'subject',
        'inbox_id': 'inboxId',
        'header_id': 'headerId',
        'delivered': 'delivered',
        'exception_name': 'exceptionName',
        'message': 'message',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt'
    }

    def __init__(self, id=None, user_id=None, subject=None, inbox_id=None, header_id=None, delivered=None, exception_name=None, message=None, created_at=None, updated_at=None, local_vars_configuration=None):  # noqa: E501
        """SendWithQueueResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._subject = None
        self._inbox_id = None
        self._header_id = None
        self._delivered = None
        self._exception_name = None
        self._message = None
        self._created_at = None
        self._updated_at = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        if subject is not None:
            self.subject = subject
        if inbox_id is not None:
            self.inbox_id = inbox_id
        self.header_id = header_id
        self.delivered = delivered
        if exception_name is not None:
            self.exception_name = exception_name
        if message is not None:
            self.message = message
        self.created_at = created_at
        self.updated_at = updated_at

    @property
    def id(self):
        """Gets the id of this SendWithQueueResult.  # noqa: E501


        :return: The id of this SendWithQueueResult.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this SendWithQueueResult.


        :param id: The id of this SendWithQueueResult.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this SendWithQueueResult.  # noqa: E501


        :return: The user_id of this SendWithQueueResult.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this SendWithQueueResult.


        :param user_id: The user_id of this SendWithQueueResult.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def subject(self):
        """Gets the subject of this SendWithQueueResult.  # noqa: E501


        :return: The subject of this SendWithQueueResult.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this SendWithQueueResult.


        :param subject: The subject of this SendWithQueueResult.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def inbox_id(self):
        """Gets the inbox_id of this SendWithQueueResult.  # noqa: E501


        :return: The inbox_id of this SendWithQueueResult.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this SendWithQueueResult.


        :param inbox_id: The inbox_id of this SendWithQueueResult.  # noqa: E501
        :type: str
        """

        self._inbox_id = inbox_id

    @property
    def header_id(self):
        """Gets the header_id of this SendWithQueueResult.  # noqa: E501


        :return: The header_id of this SendWithQueueResult.  # noqa: E501
        :rtype: str
        """
        return self._header_id

    @header_id.setter
    def header_id(self, header_id):
        """Sets the header_id of this SendWithQueueResult.


        :param header_id: The header_id of this SendWithQueueResult.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and header_id is None:  # noqa: E501
            raise ValueError("Invalid value for `header_id`, must not be `None`")  # noqa: E501

        self._header_id = header_id

    @property
    def delivered(self):
        """Gets the delivered of this SendWithQueueResult.  # noqa: E501


        :return: The delivered of this SendWithQueueResult.  # noqa: E501
        :rtype: bool
        """
        return self._delivered

    @delivered.setter
    def delivered(self, delivered):
        """Sets the delivered of this SendWithQueueResult.


        :param delivered: The delivered of this SendWithQueueResult.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and delivered is None:  # noqa: E501
            raise ValueError("Invalid value for `delivered`, must not be `None`")  # noqa: E501

        self._delivered = delivered

    @property
    def exception_name(self):
        """Gets the exception_name of this SendWithQueueResult.  # noqa: E501


        :return: The exception_name of this SendWithQueueResult.  # noqa: E501
        :rtype: str
        """
        return self._exception_name

    @exception_name.setter
    def exception_name(self, exception_name):
        """Sets the exception_name of this SendWithQueueResult.


        :param exception_name: The exception_name of this SendWithQueueResult.  # noqa: E501
        :type: str
        """

        self._exception_name = exception_name

    @property
    def message(self):
        """Gets the message of this SendWithQueueResult.  # noqa: E501


        :return: The message of this SendWithQueueResult.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this SendWithQueueResult.


        :param message: The message of this SendWithQueueResult.  # noqa: E501
        :type: str
        """

        self._message = message

    @property
    def created_at(self):
        """Gets the created_at of this SendWithQueueResult.  # noqa: E501


        :return: The created_at of this SendWithQueueResult.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this SendWithQueueResult.


        :param created_at: The created_at of this SendWithQueueResult.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this SendWithQueueResult.  # noqa: E501


        :return: The updated_at of this SendWithQueueResult.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this SendWithQueueResult.


        :param updated_at: The updated_at of this SendWithQueueResult.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SendWithQueueResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SendWithQueueResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/send_smtp_envelope_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SendSMTPEnvelopeOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'rcpt_to': 'list[str]',
        'mail_from': 'str',
        'data': 'str'
    }

    attribute_map = {
        'rcpt_to': 'rcptTo',
        'mail_from': 'mailFrom',
        'data': 'data'
    }

    def __init__(self, rcpt_to=None, mail_from=None, data=None, local_vars_configuration=None):  # noqa: E501
        """SendSMTPEnvelopeOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._rcpt_to = None
        self._mail_from = None
        self._data = None
        self.discriminator = None

        self.rcpt_to = rcpt_to
        self.mail_from = mail_from
        self.data = data

    @property
    def rcpt_to(self):
        """Gets the rcpt_to of this SendSMTPEnvelopeOptions.  # noqa: E501


        :return: The rcpt_to of this SendSMTPEnvelopeOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._rcpt_to

    @rcpt_to.setter
    def rcpt_to(self, rcpt_to):
        """Sets the rcpt_to of this SendSMTPEnvelopeOptions.


        :param rcpt_to: The rcpt_to of this SendSMTPEnvelopeOptions.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and rcpt_to is None:  # noqa: E501
            raise ValueError("Invalid value for `rcpt_to`, must not be `None`")  # noqa: E501

        self._rcpt_to = rcpt_to

    @property
    def mail_from(self):
        """Gets the mail_from of this SendSMTPEnvelopeOptions.  # noqa: E501


        :return: The mail_from of this SendSMTPEnvelopeOptions.  # noqa: E501
        :rtype: str
        """
        return self._mail_from

    @mail_from.setter
    def mail_from(self, mail_from):
        """Sets the mail_from of this SendSMTPEnvelopeOptions.


        :param mail_from: The mail_from of this SendSMTPEnvelopeOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and mail_from is None:  # noqa: E501
            raise ValueError("Invalid value for `mail_from`, must not be `None`")  # noqa: E501

        self._mail_from = mail_from

    @property
    def data(self):
        """Gets the data of this SendSMTPEnvelopeOptions.  # noqa: E501


        :return: The data of this SendSMTPEnvelopeOptions.  # noqa: E501
        :rtype: str
        """
        return self._data

    @data.setter
    def data(self, data):
        """Sets the data of this SendSMTPEnvelopeOptions.


        :param data: The data of this SendSMTPEnvelopeOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and data is None:  # noqa: E501
            raise ValueError("Invalid value for `data`, must not be `None`")  # noqa: E501

        self._data = data

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SendSMTPEnvelopeOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SendSMTPEnvelopeOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/send_email_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SendEmailOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'to_contacts': 'list[str]',
        'to_group': 'str',
        'to': 'list[str]',
        '_from': 'str',
        'cc': 'list[str]',
        'bcc': 'list[str]',
        'subject': 'str',
        'reply_to': 'str',
        'custom_headers': 'dict(str, str)',
        'body': 'str',
        'html': 'bool',
        'is_html': 'bool',
        'charset': 'str',
        'attachments': 'list[str]',
        'template_variables': 'dict(str, object)',
        'template': 'str',
        'send_strategy': 'str',
        'use_inbox_name': 'bool',
        'add_tracking_pixel': 'bool',
        'filter_bounced_recipients': 'bool',
        'validate_email_addresses': 'str',
        'ignore_empty_recipients': 'bool',
        'is_x_amp_html': 'bool',
        'body_parts': 'list[SendEmailBodyPart]'
    }

    attribute_map = {
        'to_contacts': 'toContacts',
        'to_group': 'toGroup',
        'to': 'to',
        '_from': 'from',
        'cc': 'cc',
        'bcc': 'bcc',
        'subject': 'subject',
        'reply_to': 'replyTo',
        'custom_headers': 'customHeaders',
        'body': 'body',
        'html': 'html',
        'is_html': 'isHTML',
        'charset': 'charset',
        'attachments': 'attachments',
        'template_variables': 'templateVariables',
        'template': 'template',
        'send_strategy': 'sendStrategy',
        'use_inbox_name': 'useInboxName',
        'add_tracking_pixel': 'addTrackingPixel',
        'filter_bounced_recipients': 'filterBouncedRecipients',
        'validate_email_addresses': 'validateEmailAddresses',
        'ignore_empty_recipients': 'ignoreEmptyRecipients',
        'is_x_amp_html': 'isXAmpHtml',
        'body_parts': 'bodyParts'
    }

    def __init__(self, to_contacts=None, to_group=None, to=None, _from=None, cc=None, bcc=None, subject=None, reply_to=None, custom_headers=None, body=None, html=None, is_html=None, charset=None, attachments=None, template_variables=None, template=None, send_strategy=None, use_inbox_name=None, add_tracking_pixel=None, filter_bounced_recipients=None, validate_email_addresses=None, ignore_empty_recipients=None, is_x_amp_html=None, body_parts=None, local_vars_configuration=None):  # noqa: E501
        """SendEmailOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._to_contacts = None
        self._to_group = None
        self._to = None
        self.__from = None
        self._cc = None
        self._bcc = None
        self._subject = None
        self._reply_to = None
        self._custom_headers = None
        self._body = None
        self._html = None
        self._is_html = None
        self._charset = None
        self._attachments = None
        self._template_variables = None
        self._template = None
        self._send_strategy = None
        self._use_inbox_name = None
        self._add_tracking_pixel = None
        self._filter_bounced_recipients = None
        self._validate_email_addresses = None
        self._ignore_empty_recipients = None
        self._is_x_amp_html = None
        self._body_parts = None
        self.discriminator = None

        self.to_contacts = to_contacts
        self.to_group = to_group
        self.to = to
        self._from = _from
        self.cc = cc
        self.bcc = bcc
        self.subject = subject
        self.reply_to = reply_to
        self.custom_headers = custom_headers
        self.body = body
        self.html = html
        self.is_html = is_html
        self.charset = charset
        self.attachments = attachments
        self.template_variables = template_variables
        self.template = template
        self.send_strategy = send_strategy
        self.use_inbox_name = use_inbox_name
        self.add_tracking_pixel = add_tracking_pixel
        self.filter_bounced_recipients = filter_bounced_recipients
        self.validate_email_addresses = validate_email_addresses
        self.ignore_empty_recipients = ignore_empty_recipients
        self.is_x_amp_html = is_x_amp_html
        self.body_parts = body_parts

    @property
    def to_contacts(self):
        """Gets the to_contacts of this SendEmailOptions.  # noqa: E501

        Optional list of contact IDs to send email to. Manage your contacts via the API or dashboard. When contacts are used the email is sent to each contact separately so they will not see other recipients.  # noqa: E501

        :return: The to_contacts of this SendEmailOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._to_contacts

    @to_contacts.setter
    def to_contacts(self, to_contacts):
        """Sets the to_contacts of this SendEmailOptions.

        Optional list of contact IDs to send email to. Manage your contacts via the API or dashboard. When contacts are used the email is sent to each contact separately so they will not see other recipients.  # noqa: E501

        :param to_contacts: The to_contacts of this SendEmailOptions.  # noqa: E501
        :type: list[str]
        """

        self._to_contacts = to_contacts

    @property
    def to_group(self):
        """Gets the to_group of this SendEmailOptions.  # noqa: E501

        Optional contact group ID to send email to. You can create contacts and contact groups in the API or dashboard and use them for email campaigns. When contact groups are used the email is sent to each contact separately so they will not see other recipients  # noqa: E501

        :return: The to_group of this SendEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._to_group

    @to_group.setter
    def to_group(self, to_group):
        """Sets the to_group of this SendEmailOptions.

        Optional contact group ID to send email to. You can create contacts and contact groups in the API or dashboard and use them for email campaigns. When contact groups are used the email is sent to each contact separately so they will not see other recipients  # noqa: E501

        :param to_group: The to_group of this SendEmailOptions.  # noqa: E501
        :type: str
        """

        self._to_group = to_group

    @property
    def to(self):
        """Gets the to of this SendEmailOptions.  # noqa: E501

        List of destination email addresses. Each email address must be RFC 5322 format. Even single recipients must be in array form. Maximum recipients per email depends on your plan. If you need to send many emails try using contacts or contact groups or use a non standard sendStrategy to ensure that spam filters are not triggered (many recipients in one email can affect your spam rating). Be cautious when sending emails that your recipients exist. High bounce rates (meaning a high percentage of emails cannot be delivered because an address does not exist) can result in account freezing.  # noqa: E501

        :return: The to of this SendEmailOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._to

    @to.setter
    def to(self, to):
        """Sets the to of this SendEmailOptions.

        List of destination email addresses. Each email address must be RFC 5322 format. Even single recipients must be in array form. Maximum recipients per email depends on your plan. If you need to send many emails try using contacts or contact groups or use a non standard sendStrategy to ensure that spam filters are not triggered (many recipients in one email can affect your spam rating). Be cautious when sending emails that your recipients exist. High bounce rates (meaning a high percentage of emails cannot be delivered because an address does not exist) can result in account freezing.  # noqa: E501

        :param to: The to of this SendEmailOptions.  # noqa: E501
        :type: list[str]
        """

        self._to = to

    @property
    def _from(self):
        """Gets the _from of this SendEmailOptions.  # noqa: E501

        Optional from address. Email address is RFC 5322 format and may include a display name and email in angle brackets (`my@address.com` or `My inbox <my@address.com>`). If no sender is set the source inbox address will be used for this field. If you set `useInboxName` to `true` the from field will include the inbox name as a display name: `inbox_name <inbox@address.com>`. For this to work use the name field when creating an inbox. Beware of potential spam penalties when setting the from field to an address not used by the inbox. Your emails may get blocked by services if you impersonate another address. To use a custom email addresses use a custom domain. You can create domains with the DomainController. The domain must be verified in the dashboard before it can be used.  # noqa: E501

        :return: The _from of this SendEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self.__from

    @_from.setter
    def _from(self, _from):
        """Sets the _from of this SendEmailOptions.

        Optional from address. Email address is RFC 5322 format and may include a display name and email in angle brackets (`my@address.com` or `My inbox <my@address.com>`). If no sender is set the source inbox address will be used for this field. If you set `useInboxName` to `true` the from field will include the inbox name as a display name: `inbox_name <inbox@address.com>`. For this to work use the name field when creating an inbox. Beware of potential spam penalties when setting the from field to an address not used by the inbox. Your emails may get blocked by services if you impersonate another address. To use a custom email addresses use a custom domain. You can create domains with the DomainController. The domain must be verified in the dashboard before it can be used.  # noqa: E501

        :param _from: The _from of this SendEmailOptions.  # noqa: E501
        :type: str
        """

        self.__from = _from

    @property
    def cc(self):
        """Gets the cc of this SendEmailOptions.  # noqa: E501

        Optional list of cc destination email addresses  # noqa: E501

        :return: The cc of this SendEmailOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._cc

    @cc.setter
    def cc(self, cc):
        """Sets the cc of this SendEmailOptions.

        Optional list of cc destination email addresses  # noqa: E501

        :param cc: The cc of this SendEmailOptions.  # noqa: E501
        :type: list[str]
        """

        self._cc = cc

    @property
    def bcc(self):
        """Gets the bcc of this SendEmailOptions.  # noqa: E501

        Optional list of bcc destination email addresses  # noqa: E501

        :return: The bcc of this SendEmailOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._bcc

    @bcc.setter
    def bcc(self, bcc):
        """Sets the bcc of this SendEmailOptions.

        Optional list of bcc destination email addresses  # noqa: E501

        :param bcc: The bcc of this SendEmailOptions.  # noqa: E501
        :type: list[str]
        """

        self._bcc = bcc

    @property
    def subject(self):
        """Gets the subject of this SendEmailOptions.  # noqa: E501

        Optional email subject line  # noqa: E501

        :return: The subject of this SendEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this SendEmailOptions.

        Optional email subject line  # noqa: E501

        :param subject: The subject of this SendEmailOptions.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def reply_to(self):
        """Gets the reply_to of this SendEmailOptions.  # noqa: E501

        Optional replyTo header  # noqa: E501

        :return: The reply_to of this SendEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._reply_to

    @reply_to.setter
    def reply_to(self, reply_to):
        """Sets the reply_to of this SendEmailOptions.

        Optional replyTo header  # noqa: E501

        :param reply_to: The reply_to of this SendEmailOptions.  # noqa: E501
        :type: str
        """

        self._reply_to = reply_to

    @property
    def custom_headers(self):
        """Gets the custom_headers of this SendEmailOptions.  # noqa: E501

        Optional custom headers  # noqa: E501

        :return: The custom_headers of this SendEmailOptions.  # noqa: E501
        :rtype: dict(str, str)
        """
        return self._custom_headers

    @custom_headers.setter
    def custom_headers(self, custom_headers):
        """Sets the custom_headers of this SendEmailOptions.

        Optional custom headers  # noqa: E501

        :param custom_headers: The custom_headers of this SendEmailOptions.  # noqa: E501
        :type: dict(str, str)
        """

        self._custom_headers = custom_headers

    @property
    def body(self):
        """Gets the body of this SendEmailOptions.  # noqa: E501

        Optional contents of email. If body contains HTML then set `isHTML` to true to ensure that email clients render it correctly. You can use moustache template syntax in the email body in conjunction with `toGroup` contact variables or `templateVariables` data. If you need more templating control consider creating a template and using the `template` property instead of the body.  # noqa: E501

        :return: The body of this SendEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this SendEmailOptions.

        Optional contents of email. If body contains HTML then set `isHTML` to true to ensure that email clients render it correctly. You can use moustache template syntax in the email body in conjunction with `toGroup` contact variables or `templateVariables` data. If you need more templating control consider creating a template and using the `template` property instead of the body.  # noqa: E501

        :param body: The body of this SendEmailOptions.  # noqa: E501
        :type: str
        """

        self._body = body

    @property
    def html(self):
        """Gets the html of this SendEmailOptions.  # noqa: E501

        Optional HTML flag to indicate that contents is HTML. Set's a `content-type: text/html` for email. (Deprecated: use `isHTML` instead.)  # noqa: E501

        :return: The html of this SendEmailOptions.  # noqa: E501
        :rtype: bool
        """
        return self._html

    @html.setter
    def html(self, html):
        """Sets the html of this SendEmailOptions.

        Optional HTML flag to indicate that contents is HTML. Set's a `content-type: text/html` for email. (Deprecated: use `isHTML` instead.)  # noqa: E501

        :param html: The html of this SendEmailOptions.  # noqa: E501
        :type: bool
        """

        self._html = html

    @property
    def is_html(self):
        """Gets the is_html of this SendEmailOptions.  # noqa: E501

        Optional HTML flag. If true the `content-type` of the email will be `text/html`. Set to true when sending HTML to ensure proper rending on email clients  # noqa: E501

        :return: The is_html of this SendEmailOptions.  # noqa: E501
        :rtype: bool
        """
        return self._is_html

    @is_html.setter
    def is_html(self, is_html):
        """Sets the is_html of this SendEmailOptions.

        Optional HTML flag. If true the `content-type` of the email will be `text/html`. Set to true when sending HTML to ensure proper rending on email clients  # noqa: E501

        :param is_html: The is_html of this SendEmailOptions.  # noqa: E501
        :type: bool
        """

        self._is_html = is_html

    @property
    def charset(self):
        """Gets the charset of this SendEmailOptions.  # noqa: E501

        Optional charset  # noqa: E501

        :return: The charset of this SendEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._charset

    @charset.setter
    def charset(self, charset):
        """Sets the charset of this SendEmailOptions.

        Optional charset  # noqa: E501

        :param charset: The charset of this SendEmailOptions.  # noqa: E501
        :type: str
        """

        self._charset = charset

    @property
    def attachments(self):
        """Gets the attachments of this SendEmailOptions.  # noqa: E501

        Optional list of attachment IDs to send with this email. You must first upload each attachment separately via method call or dashboard in order to obtain attachment IDs. This way you can reuse attachments with different emails once uploaded. There are several ways to upload that support `multi-part form`, `base64 file encoding`, and octet stream binary uploads. See the `UploadController` for available methods.   # noqa: E501

        :return: The attachments of this SendEmailOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._attachments

    @attachments.setter
    def attachments(self, attachments):
        """Sets the attachments of this SendEmailOptions.

        Optional list of attachment IDs to send with this email. You must first upload each attachment separately via method call or dashboard in order to obtain attachment IDs. This way you can reuse attachments with different emails once uploaded. There are several ways to upload that support `multi-part form`, `base64 file encoding`, and octet stream binary uploads. See the `UploadController` for available methods.   # noqa: E501

        :param attachments: The attachments of this SendEmailOptions.  # noqa: E501
        :type: list[str]
        """

        self._attachments = attachments

    @property
    def template_variables(self):
        """Gets the template_variables of this SendEmailOptions.  # noqa: E501

        Optional map of template variables. Will replace moustache syntax variables in subject and body or template with the associated values if found.  # noqa: E501

        :return: The template_variables of this SendEmailOptions.  # noqa: E501
        :rtype: dict(str, object)
        """
        return self._template_variables

    @template_variables.setter
    def template_variables(self, template_variables):
        """Sets the template_variables of this SendEmailOptions.

        Optional map of template variables. Will replace moustache syntax variables in subject and body or template with the associated values if found.  # noqa: E501

        :param template_variables: The template_variables of this SendEmailOptions.  # noqa: E501
        :type: dict(str, object)
        """

        self._template_variables = template_variables

    @property
    def template(self):
        """Gets the template of this SendEmailOptions.  # noqa: E501

        Optional template ID to use for body. Will override body if provided. When using a template make sure you pass the corresponding map of `templateVariables`. You can find which variables are needed by fetching the template itself or viewing it in the dashboard.  # noqa: E501

        :return: The template of this SendEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._template

    @template.setter
    def template(self, template):
        """Sets the template of this SendEmailOptions.

        Optional template ID to use for body. Will override body if provided. When using a template make sure you pass the corresponding map of `templateVariables`. You can find which variables are needed by fetching the template itself or viewing it in the dashboard.  # noqa: E501

        :param template: The template of this SendEmailOptions.  # noqa: E501
        :type: str
        """

        self._template = template

    @property
    def send_strategy(self):
        """Gets the send_strategy of this SendEmailOptions.  # noqa: E501

        How an email should be sent based on its recipients  # noqa: E501

        :return: The send_strategy of this SendEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._send_strategy

    @send_strategy.setter
    def send_strategy(self, send_strategy):
        """Sets the send_strategy of this SendEmailOptions.

        How an email should be sent based on its recipients  # noqa: E501

        :param send_strategy: The send_strategy of this SendEmailOptions.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"SINGLE_MESSAGE"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and send_strategy not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `send_strategy` ({0}), must be one of {1}"  # noqa: E501
                .format(send_strategy, allowed_values)
            )

        self._send_strategy = send_strategy

    @property
    def use_inbox_name(self):
        """Gets the use_inbox_name of this SendEmailOptions.  # noqa: E501

        Use name of inbox as sender email address name. Will construct RFC 5322 email address with `Inbox name <inbox@address.com>` if the inbox has a name.  # noqa: E501

        :return: The use_inbox_name of this SendEmailOptions.  # noqa: E501
        :rtype: bool
        """
        return self._use_inbox_name

    @use_inbox_name.setter
    def use_inbox_name(self, use_inbox_name):
        """Sets the use_inbox_name of this SendEmailOptions.

        Use name of inbox as sender email address name. Will construct RFC 5322 email address with `Inbox name <inbox@address.com>` if the inbox has a name.  # noqa: E501

        :param use_inbox_name: The use_inbox_name of this SendEmailOptions.  # noqa: E501
        :type: bool
        """

        self._use_inbox_name = use_inbox_name

    @property
    def add_tracking_pixel(self):
        """Gets the add_tracking_pixel of this SendEmailOptions.  # noqa: E501

        Add tracking pixel to email  # noqa: E501

        :return: The add_tracking_pixel of this SendEmailOptions.  # noqa: E501
        :rtype: bool
        """
        return self._add_tracking_pixel

    @add_tracking_pixel.setter
    def add_tracking_pixel(self, add_tracking_pixel):
        """Sets the add_tracking_pixel of this SendEmailOptions.

        Add tracking pixel to email  # noqa: E501

        :param add_tracking_pixel: The add_tracking_pixel of this SendEmailOptions.  # noqa: E501
        :type: bool
        """

        self._add_tracking_pixel = add_tracking_pixel

    @property
    def filter_bounced_recipients(self):
        """Gets the filter_bounced_recipients of this SendEmailOptions.  # noqa: E501

        Filter recipients to remove any bounced recipients from to, bcc, and cc before sending  # noqa: E501

        :return: The filter_bounced_recipients of this SendEmailOptions.  # noqa: E501
        :rtype: bool
        """
        return self._filter_bounced_recipients

    @filter_bounced_recipients.setter
    def filter_bounced_recipients(self, filter_bounced_recipients):
        """Sets the filter_bounced_recipients of this SendEmailOptions.

        Filter recipients to remove any bounced recipients from to, bcc, and cc before sending  # noqa: E501

        :param filter_bounced_recipients: The filter_bounced_recipients of this SendEmailOptions.  # noqa: E501
        :type: bool
        """

        self._filter_bounced_recipients = filter_bounced_recipients

    @property
    def validate_email_addresses(self):
        """Gets the validate_email_addresses of this SendEmailOptions.  # noqa: E501

        Validate recipient email addresses before sending  # noqa: E501

        :return: The validate_email_addresses of this SendEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._validate_email_addresses

    @validate_email_addresses.setter
    def validate_email_addresses(self, validate_email_addresses):
        """Sets the validate_email_addresses of this SendEmailOptions.

        Validate recipient email addresses before sending  # noqa: E501

        :param validate_email_addresses: The validate_email_addresses of this SendEmailOptions.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"VALIDATE_FILTER_REMOVE_INVALID", "VALIDATE_ERROR_IF_INVALID", "NO_VALIDATION"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and validate_email_addresses not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `validate_email_addresses` ({0}), must be one of {1}"  # noqa: E501
                .format(validate_email_addresses, allowed_values)
            )

        self._validate_email_addresses = validate_email_addresses

    @property
    def ignore_empty_recipients(self):
        """Gets the ignore_empty_recipients of this SendEmailOptions.  # noqa: E501

        Ignore empty recipients after validation removes all recipients as invalid and fail silently  # noqa: E501

        :return: The ignore_empty_recipients of this SendEmailOptions.  # noqa: E501
        :rtype: bool
        """
        return self._ignore_empty_recipients

    @ignore_empty_recipients.setter
    def ignore_empty_recipients(self, ignore_empty_recipients):
        """Sets the ignore_empty_recipients of this SendEmailOptions.

        Ignore empty recipients after validation removes all recipients as invalid and fail silently  # noqa: E501

        :param ignore_empty_recipients: The ignore_empty_recipients of this SendEmailOptions.  # noqa: E501
        :type: bool
        """

        self._ignore_empty_recipients = ignore_empty_recipients

    @property
    def is_x_amp_html(self):
        """Gets the is_x_amp_html of this SendEmailOptions.  # noqa: E501

        Is content AMP4EMAIL compatible. If set will send as x-amp-html part.  # noqa: E501

        :return: The is_x_amp_html of this SendEmailOptions.  # noqa: E501
        :rtype: bool
        """
        return self._is_x_amp_html

    @is_x_amp_html.setter
    def is_x_amp_html(self, is_x_amp_html):
        """Sets the is_x_amp_html of this SendEmailOptions.

        Is content AMP4EMAIL compatible. If set will send as x-amp-html part.  # noqa: E501

        :param is_x_amp_html: The is_x_amp_html of this SendEmailOptions.  # noqa: E501
        :type: bool
        """

        self._is_x_amp_html = is_x_amp_html

    @property
    def body_parts(self):
        """Gets the body_parts of this SendEmailOptions.  # noqa: E501

        Email body content parts for multipart mime message. Will override body.  # noqa: E501

        :return: The body_parts of this SendEmailOptions.  # noqa: E501
        :rtype: list[SendEmailBodyPart]
        """
        return self._body_parts

    @body_parts.setter
    def body_parts(self, body_parts):
        """Sets the body_parts of this SendEmailOptions.

        Email body content parts for multipart mime message. Will override body.  # noqa: E501

        :param body_parts: The body_parts of this SendEmailOptions.  # noqa: E501
        :type: list[SendEmailBodyPart]
        """

        self._body_parts = body_parts

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SendEmailOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SendEmailOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/send_email_body_part.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SendEmailBodyPart(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content_type': 'str',
        'content_body': 'str'
    }

    attribute_map = {
        'content_type': 'contentType',
        'content_body': 'contentBody'
    }

    def __init__(self, content_type=None, content_body=None, local_vars_configuration=None):  # noqa: E501
        """SendEmailBodyPart - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content_type = None
        self._content_body = None
        self.discriminator = None

        self.content_type = content_type
        self.content_body = content_body

    @property
    def content_type(self):
        """Gets the content_type of this SendEmailBodyPart.  # noqa: E501


        :return: The content_type of this SendEmailBodyPart.  # noqa: E501
        :rtype: str
        """
        return self._content_type

    @content_type.setter
    def content_type(self, content_type):
        """Sets the content_type of this SendEmailBodyPart.


        :param content_type: The content_type of this SendEmailBodyPart.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and content_type is None:  # noqa: E501
            raise ValueError("Invalid value for `content_type`, must not be `None`")  # noqa: E501

        self._content_type = content_type

    @property
    def content_body(self):
        """Gets the content_body of this SendEmailBodyPart.  # noqa: E501


        :return: The content_body of this SendEmailBodyPart.  # noqa: E501
        :rtype: str
        """
        return self._content_body

    @content_body.setter
    def content_body(self, content_body):
        """Sets the content_body of this SendEmailBodyPart.


        :param content_body: The content_body of this SendEmailBodyPart.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and content_body is None:  # noqa: E501
            raise ValueError("Invalid value for `content_body`, must not be `None`")  # noqa: E501

        self._content_body = content_body

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SendEmailBodyPart):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SendEmailBodyPart):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/search_inboxes_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SearchInboxesOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'page_index': 'int',
        'page_size': 'int',
        'sort_direction': 'str',
        'favourite': 'bool',
        'search': 'str',
        'tag': 'str',
        'since': 'datetime',
        'before': 'datetime',
        'inbox_type': 'str',
        'inbox_function': 'str',
        'domain_id': 'str'
    }

    attribute_map = {
        'page_index': 'pageIndex',
        'page_size': 'pageSize',
        'sort_direction': 'sortDirection',
        'favourite': 'favourite',
        'search': 'search',
        'tag': 'tag',
        'since': 'since',
        'before': 'before',
        'inbox_type': 'inboxType',
        'inbox_function': 'inboxFunction',
        'domain_id': 'domainId'
    }

    def __init__(self, page_index=None, page_size=None, sort_direction=None, favourite=None, search=None, tag=None, since=None, before=None, inbox_type=None, inbox_function=None, domain_id=None, local_vars_configuration=None):  # noqa: E501
        """SearchInboxesOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._page_index = None
        self._page_size = None
        self._sort_direction = None
        self._favourite = None
        self._search = None
        self._tag = None
        self._since = None
        self._before = None
        self._inbox_type = None
        self._inbox_function = None
        self._domain_id = None
        self.discriminator = None

        self.page_index = page_index
        self.page_size = page_size
        self.sort_direction = sort_direction
        self.favourite = favourite
        self.search = search
        self.tag = tag
        self.since = since
        self.before = before
        self.inbox_type = inbox_type
        self.inbox_function = inbox_function
        self.domain_id = domain_id

    @property
    def page_index(self):
        """Gets the page_index of this SearchInboxesOptions.  # noqa: E501

        Optional page index in list pagination  # noqa: E501

        :return: The page_index of this SearchInboxesOptions.  # noqa: E501
        :rtype: int
        """
        return self._page_index

    @page_index.setter
    def page_index(self, page_index):
        """Sets the page_index of this SearchInboxesOptions.

        Optional page index in list pagination  # noqa: E501

        :param page_index: The page_index of this SearchInboxesOptions.  # noqa: E501
        :type: int
        """

        self._page_index = page_index

    @property
    def page_size(self):
        """Gets the page_size of this SearchInboxesOptions.  # noqa: E501

        Optional page size in list pagination  # noqa: E501

        :return: The page_size of this SearchInboxesOptions.  # noqa: E501
        :rtype: int
        """
        return self._page_size

    @page_size.setter
    def page_size(self, page_size):
        """Sets the page_size of this SearchInboxesOptions.

        Optional page size in list pagination  # noqa: E501

        :param page_size: The page_size of this SearchInboxesOptions.  # noqa: E501
        :type: int
        """

        self._page_size = page_size

    @property
    def sort_direction(self):
        """Gets the sort_direction of this SearchInboxesOptions.  # noqa: E501

        Optional createdAt sort direction ASC or DESC  # noqa: E501

        :return: The sort_direction of this SearchInboxesOptions.  # noqa: E501
        :rtype: str
        """
        return self._sort_direction

    @sort_direction.setter
    def sort_direction(self, sort_direction):
        """Sets the sort_direction of this SearchInboxesOptions.

        Optional createdAt sort direction ASC or DESC  # noqa: E501

        :param sort_direction: The sort_direction of this SearchInboxesOptions.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"ASC", "DESC"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and sort_direction not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `sort_direction` ({0}), must be one of {1}"  # noqa: E501
                .format(sort_direction, allowed_values)
            )

        self._sort_direction = sort_direction

    @property
    def favourite(self):
        """Gets the favourite of this SearchInboxesOptions.  # noqa: E501

        Optionally filter results for favourites only  # noqa: E501

        :return: The favourite of this SearchInboxesOptions.  # noqa: E501
        :rtype: bool
        """
        return self._favourite

    @favourite.setter
    def favourite(self, favourite):
        """Sets the favourite of this SearchInboxesOptions.

        Optionally filter results for favourites only  # noqa: E501

        :param favourite: The favourite of this SearchInboxesOptions.  # noqa: E501
        :type: bool
        """

        self._favourite = favourite

    @property
    def search(self):
        """Gets the search of this SearchInboxesOptions.  # noqa: E501

        Optionally filter by search words partial matching ID, tags, name, and email address  # noqa: E501

        :return: The search of this SearchInboxesOptions.  # noqa: E501
        :rtype: str
        """
        return self._search

    @search.setter
    def search(self, search):
        """Sets the search of this SearchInboxesOptions.

        Optionally filter by search words partial matching ID, tags, name, and email address  # noqa: E501

        :param search: The search of this SearchInboxesOptions.  # noqa: E501
        :type: str
        """

        self._search = search

    @property
    def tag(self):
        """Gets the tag of this SearchInboxesOptions.  # noqa: E501

        Optionally filter by tags. Will return inboxes that include given tags  # noqa: E501

        :return: The tag of this SearchInboxesOptions.  # noqa: E501
        :rtype: str
        """
        return self._tag

    @tag.setter
    def tag(self, tag):
        """Sets the tag of this SearchInboxesOptions.

        Optionally filter by tags. Will return inboxes that include given tags  # noqa: E501

        :param tag: The tag of this SearchInboxesOptions.  # noqa: E501
        :type: str
        """

        self._tag = tag

    @property
    def since(self):
        """Gets the since of this SearchInboxesOptions.  # noqa: E501

        Optional filter by created after given date time  # noqa: E501

        :return: The since of this SearchInboxesOptions.  # noqa: E501
        :rtype: datetime
        """
        return self._since

    @since.setter
    def since(self, since):
        """Sets the since of this SearchInboxesOptions.

        Optional filter by created after given date time  # noqa: E501

        :param since: The since of this SearchInboxesOptions.  # noqa: E501
        :type: datetime
        """

        self._since = since

    @property
    def before(self):
        """Gets the before of this SearchInboxesOptions.  # noqa: E501

        Optional filter by created before given date time  # noqa: E501

        :return: The before of this SearchInboxesOptions.  # noqa: E501
        :rtype: datetime
        """
        return self._before

    @before.setter
    def before(self, before):
        """Sets the before of this SearchInboxesOptions.

        Optional filter by created before given date time  # noqa: E501

        :param before: The before of this SearchInboxesOptions.  # noqa: E501
        :type: datetime
        """

        self._before = before

    @property
    def inbox_type(self):
        """Gets the inbox_type of this SearchInboxesOptions.  # noqa: E501

        Type of inbox. HTTP inboxes are faster and better for most cases. SMTP inboxes are more suited for public facing inbound messages (but cannot send).  # noqa: E501

        :return: The inbox_type of this SearchInboxesOptions.  # noqa: E501
        :rtype: str
        """
        return self._inbox_type

    @inbox_type.setter
    def inbox_type(self, inbox_type):
        """Sets the inbox_type of this SearchInboxesOptions.

        Type of inbox. HTTP inboxes are faster and better for most cases. SMTP inboxes are more suited for public facing inbound messages (but cannot send).  # noqa: E501

        :param inbox_type: The inbox_type of this SearchInboxesOptions.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"HTTP_INBOX", "SMTP_INBOX"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and inbox_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `inbox_type` ({0}), must be one of {1}"  # noqa: E501
                .format(inbox_type, allowed_values)
            )

        self._inbox_type = inbox_type

    @property
    def inbox_function(self):
        """Gets the inbox_function of this SearchInboxesOptions.  # noqa: E501

        Optional filter by inbox function  # noqa: E501

        :return: The inbox_function of this SearchInboxesOptions.  # noqa: E501
        :rtype: str
        """
        return self._inbox_function

    @inbox_function.setter
    def inbox_function(self, inbox_function):
        """Sets the inbox_function of this SearchInboxesOptions.

        Optional filter by inbox function  # noqa: E501

        :param inbox_function: The inbox_function of this SearchInboxesOptions.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"ALIAS", "THREAD", "CATCH_ALL", "CONNECTOR"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and inbox_function not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `inbox_function` ({0}), must be one of {1}"  # noqa: E501
                .format(inbox_function, allowed_values)
            )

        self._inbox_function = inbox_function

    @property
    def domain_id(self):
        """Gets the domain_id of this SearchInboxesOptions.  # noqa: E501

        Optional domain ID filter  # noqa: E501

        :return: The domain_id of this SearchInboxesOptions.  # noqa: E501
        :rtype: str
        """
        return self._domain_id

    @domain_id.setter
    def domain_id(self, domain_id):
        """Sets the domain_id of this SearchInboxesOptions.

        Optional domain ID filter  # noqa: E501

        :param domain_id: The domain_id of this SearchInboxesOptions.  # noqa: E501
        :type: str
        """

        self._domain_id = domain_id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SearchInboxesOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SearchInboxesOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/search_emails_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class SearchEmailsOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'inbox_ids': 'list[str]',
        'page_index': 'int',
        'page_size': 'int',
        'sort_direction': 'str',
        'unread_only': 'bool',
        'search_filter': 'str',
        'since': 'datetime',
        'before': 'datetime'
    }

    attribute_map = {
        'inbox_ids': 'inboxIds',
        'page_index': 'pageIndex',
        'page_size': 'pageSize',
        'sort_direction': 'sortDirection',
        'unread_only': 'unreadOnly',
        'search_filter': 'searchFilter',
        'since': 'since',
        'before': 'before'
    }

    def __init__(self, inbox_ids=None, page_index=None, page_size=None, sort_direction=None, unread_only=None, search_filter=None, since=None, before=None, local_vars_configuration=None):  # noqa: E501
        """SearchEmailsOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._inbox_ids = None
        self._page_index = None
        self._page_size = None
        self._sort_direction = None
        self._unread_only = None
        self._search_filter = None
        self._since = None
        self._before = None
        self.discriminator = None

        if inbox_ids is not None:
            self.inbox_ids = inbox_ids
        if page_index is not None:
            self.page_index = page_index
        if page_size is not None:
            self.page_size = page_size
        if sort_direction is not None:
            self.sort_direction = sort_direction
        if unread_only is not None:
            self.unread_only = unread_only
        if search_filter is not None:
            self.search_filter = search_filter
        if since is not None:
            self.since = since
        if before is not None:
            self.before = before

    @property
    def inbox_ids(self):
        """Gets the inbox_ids of this SearchEmailsOptions.  # noqa: E501

        Optional inbox ids to filter by. Can be repeated. By default will use all inboxes belonging to your account.  # noqa: E501

        :return: The inbox_ids of this SearchEmailsOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._inbox_ids

    @inbox_ids.setter
    def inbox_ids(self, inbox_ids):
        """Sets the inbox_ids of this SearchEmailsOptions.

        Optional inbox ids to filter by. Can be repeated. By default will use all inboxes belonging to your account.  # noqa: E501

        :param inbox_ids: The inbox_ids of this SearchEmailsOptions.  # noqa: E501
        :type: list[str]
        """

        self._inbox_ids = inbox_ids

    @property
    def page_index(self):
        """Gets the page_index of this SearchEmailsOptions.  # noqa: E501

        Optional page index in email list pagination  # noqa: E501

        :return: The page_index of this SearchEmailsOptions.  # noqa: E501
        :rtype: int
        """
        return self._page_index

    @page_index.setter
    def page_index(self, page_index):
        """Sets the page_index of this SearchEmailsOptions.

        Optional page index in email list pagination  # noqa: E501

        :param page_index: The page_index of this SearchEmailsOptions.  # noqa: E501
        :type: int
        """

        self._page_index = page_index

    @property
    def page_size(self):
        """Gets the page_size of this SearchEmailsOptions.  # noqa: E501

        Optional page size in email list pagination. Maximum size is 100. Use page index and sort to page through larger results  # noqa: E501

        :return: The page_size of this SearchEmailsOptions.  # noqa: E501
        :rtype: int
        """
        return self._page_size

    @page_size.setter
    def page_size(self, page_size):
        """Sets the page_size of this SearchEmailsOptions.

        Optional page size in email list pagination. Maximum size is 100. Use page index and sort to page through larger results  # noqa: E501

        :param page_size: The page_size of this SearchEmailsOptions.  # noqa: E501
        :type: int
        """
        if (self.local_vars_configuration.client_side_validation and
                page_size is not None and page_size > 100):  # noqa: E501
            raise ValueError("Invalid value for `page_size`, must be a value less than or equal to `100`")  # noqa: E501

        self._page_size = page_size

    @property
    def sort_direction(self):
        """Gets the sort_direction of this SearchEmailsOptions.  # noqa: E501

        Optional createdAt sort direction ASC or DESC  # noqa: E501

        :return: The sort_direction of this SearchEmailsOptions.  # noqa: E501
        :rtype: str
        """
        return self._sort_direction

    @sort_direction.setter
    def sort_direction(self, sort_direction):
        """Sets the sort_direction of this SearchEmailsOptions.

        Optional createdAt sort direction ASC or DESC  # noqa: E501

        :param sort_direction: The sort_direction of this SearchEmailsOptions.  # noqa: E501
        :type: str
        """
        allowed_values = ["ASC", "DESC"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and sort_direction not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `sort_direction` ({0}), must be one of {1}"  # noqa: E501
                .format(sort_direction, allowed_values)
            )

        self._sort_direction = sort_direction

    @property
    def unread_only(self):
        """Gets the unread_only of this SearchEmailsOptions.  # noqa: E501

        Optional filter for unread emails only. All emails are considered unread until they are viewed in the dashboard or requested directly  # noqa: E501

        :return: The unread_only of this SearchEmailsOptions.  # noqa: E501
        :rtype: bool
        """
        return self._unread_only

    @unread_only.setter
    def unread_only(self, unread_only):
        """Sets the unread_only of this SearchEmailsOptions.

        Optional filter for unread emails only. All emails are considered unread until they are viewed in the dashboard or requested directly  # noqa: E501

        :param unread_only: The unread_only of this SearchEmailsOptions.  # noqa: E501
        :type: bool
        """

        self._unread_only = unread_only

    @property
    def search_filter(self):
        """Gets the search_filter of this SearchEmailsOptions.  # noqa: E501

        Optional search filter. Searches email recipients, sender, subject, email address and ID. Does not search email body  # noqa: E501

        :return: The search_filter of this SearchEmailsOptions.  # noqa: E501
        :rtype: str
        """
        return self._search_filter

    @search_filter.setter
    def search_filter(self, search_filter):
        """Sets the search_filter of this SearchEmailsOptions.

        Optional search filter. Searches email recipients, sender, subject, email address and ID. Does not search email body  # noqa: E501

        :param search_filter: The search_filter of this SearchEmailsOptions.  # noqa: E501
        :type: str
        """

        self._search_filter = search_filter

    @property
    def since(self):
        """Gets the since of this SearchEmailsOptions.  # noqa: E501

        Optional filter emails received after given date time  # noqa: E501

        :return: The since of this SearchEmailsOptions.  # noqa: E501
        :rtype: datetime
        """
        return self._since

    @since.setter
    def since(self, since):
        """Sets the since of this SearchEmailsOptions.

        Optional filter emails received after given date time  # noqa: E501

        :param since: The since of this SearchEmailsOptions.  # noqa: E501
        :type: datetime
        """

        self._since = since

    @property
    def before(self):
        """Gets the before of this SearchEmailsOptions.  # noqa: E501

        Optional filter emails received before given date time  # noqa: E501

        :return: The before of this SearchEmailsOptions.  # noqa: E501
        :rtype: datetime
        """
        return self._before

    @before.setter
    def before(self, before):
        """Sets the before of this SearchEmailsOptions.

        Optional filter emails received before given date time  # noqa: E501

        :param before: The before of this SearchEmailsOptions.  # noqa: E501
        :type: datetime
        """

        self._before = before

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, SearchEmailsOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, SearchEmailsOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/scheduled_job_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ScheduledJobDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'inbox_id': 'str',
        'job_id': 'str',
        'group_id': 'str',
        'trigger_id': 'str',
        'status': 'str',
        'send_at_timestamp': 'datetime',
        'created_at': 'datetime',
        'updated_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'inbox_id': 'inboxId',
        'job_id': 'jobId',
        'group_id': 'groupId',
        'trigger_id': 'triggerId',
        'status': 'status',
        'send_at_timestamp': 'sendAtTimestamp',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt'
    }

    def __init__(self, id=None, user_id=None, inbox_id=None, job_id=None, group_id=None, trigger_id=None, status=None, send_at_timestamp=None, created_at=None, updated_at=None, local_vars_configuration=None):  # noqa: E501
        """ScheduledJobDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._inbox_id = None
        self._job_id = None
        self._group_id = None
        self._trigger_id = None
        self._status = None
        self._send_at_timestamp = None
        self._created_at = None
        self._updated_at = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        self.inbox_id = inbox_id
        self.job_id = job_id
        self.group_id = group_id
        self.trigger_id = trigger_id
        self.status = status
        self.send_at_timestamp = send_at_timestamp
        self.created_at = created_at
        self.updated_at = updated_at

    @property
    def id(self):
        """Gets the id of this ScheduledJobDto.  # noqa: E501


        :return: The id of this ScheduledJobDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this ScheduledJobDto.


        :param id: The id of this ScheduledJobDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this ScheduledJobDto.  # noqa: E501


        :return: The user_id of this ScheduledJobDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this ScheduledJobDto.


        :param user_id: The user_id of this ScheduledJobDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def inbox_id(self):
        """Gets the inbox_id of this ScheduledJobDto.  # noqa: E501


        :return: The inbox_id of this ScheduledJobDto.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this ScheduledJobDto.


        :param inbox_id: The inbox_id of this ScheduledJobDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def job_id(self):
        """Gets the job_id of this ScheduledJobDto.  # noqa: E501


        :return: The job_id of this ScheduledJobDto.  # noqa: E501
        :rtype: str
        """
        return self._job_id

    @job_id.setter
    def job_id(self, job_id):
        """Sets the job_id of this ScheduledJobDto.


        :param job_id: The job_id of this ScheduledJobDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and job_id is None:  # noqa: E501
            raise ValueError("Invalid value for `job_id`, must not be `None`")  # noqa: E501

        self._job_id = job_id

    @property
    def group_id(self):
        """Gets the group_id of this ScheduledJobDto.  # noqa: E501


        :return: The group_id of this ScheduledJobDto.  # noqa: E501
        :rtype: str
        """
        return self._group_id

    @group_id.setter
    def group_id(self, group_id):
        """Sets the group_id of this ScheduledJobDto.


        :param group_id: The group_id of this ScheduledJobDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and group_id is None:  # noqa: E501
            raise ValueError("Invalid value for `group_id`, must not be `None`")  # noqa: E501

        self._group_id = group_id

    @property
    def trigger_id(self):
        """Gets the trigger_id of this ScheduledJobDto.  # noqa: E501


        :return: The trigger_id of this ScheduledJobDto.  # noqa: E501
        :rtype: str
        """
        return self._trigger_id

    @trigger_id.setter
    def trigger_id(self, trigger_id):
        """Sets the trigger_id of this ScheduledJobDto.


        :param trigger_id: The trigger_id of this ScheduledJobDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and trigger_id is None:  # noqa: E501
            raise ValueError("Invalid value for `trigger_id`, must not be `None`")  # noqa: E501

        self._trigger_id = trigger_id

    @property
    def status(self):
        """Gets the status of this ScheduledJobDto.  # noqa: E501


        :return: The status of this ScheduledJobDto.  # noqa: E501
        :rtype: str
        """
        return self._status

    @status.setter
    def status(self, status):
        """Sets the status of this ScheduledJobDto.


        :param status: The status of this ScheduledJobDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and status is None:  # noqa: E501
            raise ValueError("Invalid value for `status`, must not be `None`")  # noqa: E501
        allowed_values = ["SUBMITTED", "COMPLETED", "ABORTED", "FAILED", "CANCELLED"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and status not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `status` ({0}), must be one of {1}"  # noqa: E501
                .format(status, allowed_values)
            )

        self._status = status

    @property
    def send_at_timestamp(self):
        """Gets the send_at_timestamp of this ScheduledJobDto.  # noqa: E501


        :return: The send_at_timestamp of this ScheduledJobDto.  # noqa: E501
        :rtype: datetime
        """
        return self._send_at_timestamp

    @send_at_timestamp.setter
    def send_at_timestamp(self, send_at_timestamp):
        """Sets the send_at_timestamp of this ScheduledJobDto.


        :param send_at_timestamp: The send_at_timestamp of this ScheduledJobDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and send_at_timestamp is None:  # noqa: E501
            raise ValueError("Invalid value for `send_at_timestamp`, must not be `None`")  # noqa: E501

        self._send_at_timestamp = send_at_timestamp

    @property
    def created_at(self):
        """Gets the created_at of this ScheduledJobDto.  # noqa: E501


        :return: The created_at of this ScheduledJobDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this ScheduledJobDto.


        :param created_at: The created_at of this ScheduledJobDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this ScheduledJobDto.  # noqa: E501


        :return: The updated_at of this ScheduledJobDto.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this ScheduledJobDto.


        :param updated_at: The updated_at of this ScheduledJobDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ScheduledJobDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ScheduledJobDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/scheduled_job.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ScheduledJob(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'inbox_id': 'str',
        'job_id': 'str',
        'group_id': 'str',
        'trigger_id': 'str',
        'status': 'str',
        'send_at_timestamp': 'datetime',
        'created_at': 'datetime',
        'updated_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'inbox_id': 'inboxId',
        'job_id': 'jobId',
        'group_id': 'groupId',
        'trigger_id': 'triggerId',
        'status': 'status',
        'send_at_timestamp': 'sendAtTimestamp',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt'
    }

    def __init__(self, id=None, user_id=None, inbox_id=None, job_id=None, group_id=None, trigger_id=None, status=None, send_at_timestamp=None, created_at=None, updated_at=None, local_vars_configuration=None):  # noqa: E501
        """ScheduledJob - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._inbox_id = None
        self._job_id = None
        self._group_id = None
        self._trigger_id = None
        self._status = None
        self._send_at_timestamp = None
        self._created_at = None
        self._updated_at = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        self.inbox_id = inbox_id
        self.job_id = job_id
        self.group_id = group_id
        self.trigger_id = trigger_id
        self.status = status
        self.send_at_timestamp = send_at_timestamp
        self.created_at = created_at
        self.updated_at = updated_at

    @property
    def id(self):
        """Gets the id of this ScheduledJob.  # noqa: E501


        :return: The id of this ScheduledJob.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this ScheduledJob.


        :param id: The id of this ScheduledJob.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this ScheduledJob.  # noqa: E501


        :return: The user_id of this ScheduledJob.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this ScheduledJob.


        :param user_id: The user_id of this ScheduledJob.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def inbox_id(self):
        """Gets the inbox_id of this ScheduledJob.  # noqa: E501


        :return: The inbox_id of this ScheduledJob.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this ScheduledJob.


        :param inbox_id: The inbox_id of this ScheduledJob.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def job_id(self):
        """Gets the job_id of this ScheduledJob.  # noqa: E501


        :return: The job_id of this ScheduledJob.  # noqa: E501
        :rtype: str
        """
        return self._job_id

    @job_id.setter
    def job_id(self, job_id):
        """Sets the job_id of this ScheduledJob.


        :param job_id: The job_id of this ScheduledJob.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and job_id is None:  # noqa: E501
            raise ValueError("Invalid value for `job_id`, must not be `None`")  # noqa: E501

        self._job_id = job_id

    @property
    def group_id(self):
        """Gets the group_id of this ScheduledJob.  # noqa: E501


        :return: The group_id of this ScheduledJob.  # noqa: E501
        :rtype: str
        """
        return self._group_id

    @group_id.setter
    def group_id(self, group_id):
        """Sets the group_id of this ScheduledJob.


        :param group_id: The group_id of this ScheduledJob.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and group_id is None:  # noqa: E501
            raise ValueError("Invalid value for `group_id`, must not be `None`")  # noqa: E501

        self._group_id = group_id

    @property
    def trigger_id(self):
        """Gets the trigger_id of this ScheduledJob.  # noqa: E501


        :return: The trigger_id of this ScheduledJob.  # noqa: E501
        :rtype: str
        """
        return self._trigger_id

    @trigger_id.setter
    def trigger_id(self, trigger_id):
        """Sets the trigger_id of this ScheduledJob.


        :param trigger_id: The trigger_id of this ScheduledJob.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and trigger_id is None:  # noqa: E501
            raise ValueError("Invalid value for `trigger_id`, must not be `None`")  # noqa: E501

        self._trigger_id = trigger_id

    @property
    def status(self):
        """Gets the status of this ScheduledJob.  # noqa: E501


        :return: The status of this ScheduledJob.  # noqa: E501
        :rtype: str
        """
        return self._status

    @status.setter
    def status(self, status):
        """Sets the status of this ScheduledJob.


        :param status: The status of this ScheduledJob.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and status is None:  # noqa: E501
            raise ValueError("Invalid value for `status`, must not be `None`")  # noqa: E501
        allowed_values = ["SUBMITTED", "COMPLETED", "ABORTED", "FAILED", "CANCELLED"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and status not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `status` ({0}), must be one of {1}"  # noqa: E501
                .format(status, allowed_values)
            )

        self._status = status

    @property
    def send_at_timestamp(self):
        """Gets the send_at_timestamp of this ScheduledJob.  # noqa: E501


        :return: The send_at_timestamp of this ScheduledJob.  # noqa: E501
        :rtype: datetime
        """
        return self._send_at_timestamp

    @send_at_timestamp.setter
    def send_at_timestamp(self, send_at_timestamp):
        """Sets the send_at_timestamp of this ScheduledJob.


        :param send_at_timestamp: The send_at_timestamp of this ScheduledJob.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and send_at_timestamp is None:  # noqa: E501
            raise ValueError("Invalid value for `send_at_timestamp`, must not be `None`")  # noqa: E501

        self._send_at_timestamp = send_at_timestamp

    @property
    def created_at(self):
        """Gets the created_at of this ScheduledJob.  # noqa: E501


        :return: The created_at of this ScheduledJob.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this ScheduledJob.


        :param created_at: The created_at of this ScheduledJob.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this ScheduledJob.  # noqa: E501


        :return: The updated_at of this ScheduledJob.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this ScheduledJob.


        :param updated_at: The updated_at of this ScheduledJob.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ScheduledJob):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ScheduledJob):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/reply_to_email_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ReplyToEmailOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'body': 'str',
        'is_html': 'bool',
        '_from': 'str',
        'reply_to': 'str',
        'custom_headers': 'dict(str, str)',
        'charset': 'str',
        'attachments': 'list[str]',
        'template_variables': 'dict(str, object)',
        'template': 'str',
        'send_strategy': 'str',
        'use_inbox_name': 'bool',
        'html': 'bool'
    }

    attribute_map = {
        'body': 'body',
        'is_html': 'isHTML',
        '_from': 'from',
        'reply_to': 'replyTo',
        'custom_headers': 'customHeaders',
        'charset': 'charset',
        'attachments': 'attachments',
        'template_variables': 'templateVariables',
        'template': 'template',
        'send_strategy': 'sendStrategy',
        'use_inbox_name': 'useInboxName',
        'html': 'html'
    }

    def __init__(self, body=None, is_html=None, _from=None, reply_to=None, custom_headers=None, charset=None, attachments=None, template_variables=None, template=None, send_strategy=None, use_inbox_name=None, html=None, local_vars_configuration=None):  # noqa: E501
        """ReplyToEmailOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._body = None
        self._is_html = None
        self.__from = None
        self._reply_to = None
        self._custom_headers = None
        self._charset = None
        self._attachments = None
        self._template_variables = None
        self._template = None
        self._send_strategy = None
        self._use_inbox_name = None
        self._html = None
        self.discriminator = None

        self.body = body
        self.is_html = is_html
        self._from = _from
        self.reply_to = reply_to
        self.custom_headers = custom_headers
        self.charset = charset
        self.attachments = attachments
        self.template_variables = template_variables
        self.template = template
        self.send_strategy = send_strategy
        self.use_inbox_name = use_inbox_name
        if html is not None:
            self.html = html

    @property
    def body(self):
        """Gets the body of this ReplyToEmailOptions.  # noqa: E501

        Body of the reply email you want to send  # noqa: E501

        :return: The body of this ReplyToEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this ReplyToEmailOptions.

        Body of the reply email you want to send  # noqa: E501

        :param body: The body of this ReplyToEmailOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and body is None:  # noqa: E501
            raise ValueError("Invalid value for `body`, must not be `None`")  # noqa: E501

        self._body = body

    @property
    def is_html(self):
        """Gets the is_html of this ReplyToEmailOptions.  # noqa: E501

        Is the reply HTML  # noqa: E501

        :return: The is_html of this ReplyToEmailOptions.  # noqa: E501
        :rtype: bool
        """
        return self._is_html

    @is_html.setter
    def is_html(self, is_html):
        """Sets the is_html of this ReplyToEmailOptions.

        Is the reply HTML  # noqa: E501

        :param is_html: The is_html of this ReplyToEmailOptions.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and is_html is None:  # noqa: E501
            raise ValueError("Invalid value for `is_html`, must not be `None`")  # noqa: E501

        self._is_html = is_html

    @property
    def _from(self):
        """Gets the _from of this ReplyToEmailOptions.  # noqa: E501

        The from header that should be used. Optional  # noqa: E501

        :return: The _from of this ReplyToEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self.__from

    @_from.setter
    def _from(self, _from):
        """Sets the _from of this ReplyToEmailOptions.

        The from header that should be used. Optional  # noqa: E501

        :param _from: The _from of this ReplyToEmailOptions.  # noqa: E501
        :type: str
        """

        self.__from = _from

    @property
    def reply_to(self):
        """Gets the reply_to of this ReplyToEmailOptions.  # noqa: E501

        The replyTo header that should be used. Optional  # noqa: E501

        :return: The reply_to of this ReplyToEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._reply_to

    @reply_to.setter
    def reply_to(self, reply_to):
        """Sets the reply_to of this ReplyToEmailOptions.

        The replyTo header that should be used. Optional  # noqa: E501

        :param reply_to: The reply_to of this ReplyToEmailOptions.  # noqa: E501
        :type: str
        """

        self._reply_to = reply_to

    @property
    def custom_headers(self):
        """Gets the custom_headers of this ReplyToEmailOptions.  # noqa: E501

        Optional custom headers  # noqa: E501

        :return: The custom_headers of this ReplyToEmailOptions.  # noqa: E501
        :rtype: dict(str, str)
        """
        return self._custom_headers

    @custom_headers.setter
    def custom_headers(self, custom_headers):
        """Sets the custom_headers of this ReplyToEmailOptions.

        Optional custom headers  # noqa: E501

        :param custom_headers: The custom_headers of this ReplyToEmailOptions.  # noqa: E501
        :type: dict(str, str)
        """

        self._custom_headers = custom_headers

    @property
    def charset(self):
        """Gets the charset of this ReplyToEmailOptions.  # noqa: E501

        The charset that your message should be sent with. Optional. Default is UTF-8  # noqa: E501

        :return: The charset of this ReplyToEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._charset

    @charset.setter
    def charset(self, charset):
        """Sets the charset of this ReplyToEmailOptions.

        The charset that your message should be sent with. Optional. Default is UTF-8  # noqa: E501

        :param charset: The charset of this ReplyToEmailOptions.  # noqa: E501
        :type: str
        """

        self._charset = charset

    @property
    def attachments(self):
        """Gets the attachments of this ReplyToEmailOptions.  # noqa: E501

        List of uploaded attachments to send with the reply. Optional.  # noqa: E501

        :return: The attachments of this ReplyToEmailOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._attachments

    @attachments.setter
    def attachments(self, attachments):
        """Sets the attachments of this ReplyToEmailOptions.

        List of uploaded attachments to send with the reply. Optional.  # noqa: E501

        :param attachments: The attachments of this ReplyToEmailOptions.  # noqa: E501
        :type: list[str]
        """

        self._attachments = attachments

    @property
    def template_variables(self):
        """Gets the template_variables of this ReplyToEmailOptions.  # noqa: E501

        Template variables if using a template  # noqa: E501

        :return: The template_variables of this ReplyToEmailOptions.  # noqa: E501
        :rtype: dict(str, object)
        """
        return self._template_variables

    @template_variables.setter
    def template_variables(self, template_variables):
        """Sets the template_variables of this ReplyToEmailOptions.

        Template variables if using a template  # noqa: E501

        :param template_variables: The template_variables of this ReplyToEmailOptions.  # noqa: E501
        :type: dict(str, object)
        """

        self._template_variables = template_variables

    @property
    def template(self):
        """Gets the template of this ReplyToEmailOptions.  # noqa: E501

        Template ID to use instead of body. Will use template variable map to fill defined variable slots.  # noqa: E501

        :return: The template of this ReplyToEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._template

    @template.setter
    def template(self, template):
        """Sets the template of this ReplyToEmailOptions.

        Template ID to use instead of body. Will use template variable map to fill defined variable slots.  # noqa: E501

        :param template: The template of this ReplyToEmailOptions.  # noqa: E501
        :type: str
        """

        self._template = template

    @property
    def send_strategy(self):
        """Gets the send_strategy of this ReplyToEmailOptions.  # noqa: E501

        How an email should be sent based on its recipients  # noqa: E501

        :return: The send_strategy of this ReplyToEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._send_strategy

    @send_strategy.setter
    def send_strategy(self, send_strategy):
        """Sets the send_strategy of this ReplyToEmailOptions.

        How an email should be sent based on its recipients  # noqa: E501

        :param send_strategy: The send_strategy of this ReplyToEmailOptions.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"SINGLE_MESSAGE"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and send_strategy not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `send_strategy` ({0}), must be one of {1}"  # noqa: E501
                .format(send_strategy, allowed_values)
            )

        self._send_strategy = send_strategy

    @property
    def use_inbox_name(self):
        """Gets the use_inbox_name of this ReplyToEmailOptions.  # noqa: E501

        Optionally use inbox name as display name for sender email address  # noqa: E501

        :return: The use_inbox_name of this ReplyToEmailOptions.  # noqa: E501
        :rtype: bool
        """
        return self._use_inbox_name

    @use_inbox_name.setter
    def use_inbox_name(self, use_inbox_name):
        """Sets the use_inbox_name of this ReplyToEmailOptions.

        Optionally use inbox name as display name for sender email address  # noqa: E501

        :param use_inbox_name: The use_inbox_name of this ReplyToEmailOptions.  # noqa: E501
        :type: bool
        """

        self._use_inbox_name = use_inbox_name

    @property
    def html(self):
        """Gets the html of this ReplyToEmailOptions.  # noqa: E501


        :return: The html of this ReplyToEmailOptions.  # noqa: E501
        :rtype: bool
        """
        return self._html

    @html.setter
    def html(self, html):
        """Sets the html of this ReplyToEmailOptions.


        :param html: The html of this ReplyToEmailOptions.  # noqa: E501
        :type: bool
        """

        self._html = html

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ReplyToEmailOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ReplyToEmailOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/reply_to_alias_email_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ReplyToAliasEmailOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'body': 'str',
        'is_html': 'bool',
        'charset': 'str',
        'attachments': 'list[str]',
        'template_variables': 'dict(str, object)',
        'template': 'str',
        'send_strategy': 'str',
        'custom_headers': 'dict(str, str)',
        'use_inbox_name': 'bool',
        'html': 'bool'
    }

    attribute_map = {
        'body': 'body',
        'is_html': 'isHTML',
        'charset': 'charset',
        'attachments': 'attachments',
        'template_variables': 'templateVariables',
        'template': 'template',
        'send_strategy': 'sendStrategy',
        'custom_headers': 'customHeaders',
        'use_inbox_name': 'useInboxName',
        'html': 'html'
    }

    def __init__(self, body=None, is_html=None, charset=None, attachments=None, template_variables=None, template=None, send_strategy=None, custom_headers=None, use_inbox_name=None, html=None, local_vars_configuration=None):  # noqa: E501
        """ReplyToAliasEmailOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._body = None
        self._is_html = None
        self._charset = None
        self._attachments = None
        self._template_variables = None
        self._template = None
        self._send_strategy = None
        self._custom_headers = None
        self._use_inbox_name = None
        self._html = None
        self.discriminator = None

        self.body = body
        self.is_html = is_html
        self.charset = charset
        self.attachments = attachments
        self.template_variables = template_variables
        self.template = template
        self.send_strategy = send_strategy
        self.custom_headers = custom_headers
        self.use_inbox_name = use_inbox_name
        if html is not None:
            self.html = html

    @property
    def body(self):
        """Gets the body of this ReplyToAliasEmailOptions.  # noqa: E501

        Body of the reply email you want to send  # noqa: E501

        :return: The body of this ReplyToAliasEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this ReplyToAliasEmailOptions.

        Body of the reply email you want to send  # noqa: E501

        :param body: The body of this ReplyToAliasEmailOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and body is None:  # noqa: E501
            raise ValueError("Invalid value for `body`, must not be `None`")  # noqa: E501

        self._body = body

    @property
    def is_html(self):
        """Gets the is_html of this ReplyToAliasEmailOptions.  # noqa: E501

        Is the reply HTML  # noqa: E501

        :return: The is_html of this ReplyToAliasEmailOptions.  # noqa: E501
        :rtype: bool
        """
        return self._is_html

    @is_html.setter
    def is_html(self, is_html):
        """Sets the is_html of this ReplyToAliasEmailOptions.

        Is the reply HTML  # noqa: E501

        :param is_html: The is_html of this ReplyToAliasEmailOptions.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and is_html is None:  # noqa: E501
            raise ValueError("Invalid value for `is_html`, must not be `None`")  # noqa: E501

        self._is_html = is_html

    @property
    def charset(self):
        """Gets the charset of this ReplyToAliasEmailOptions.  # noqa: E501

        The charset that your message should be sent with. Optional. Default is UTF-8  # noqa: E501

        :return: The charset of this ReplyToAliasEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._charset

    @charset.setter
    def charset(self, charset):
        """Sets the charset of this ReplyToAliasEmailOptions.

        The charset that your message should be sent with. Optional. Default is UTF-8  # noqa: E501

        :param charset: The charset of this ReplyToAliasEmailOptions.  # noqa: E501
        :type: str
        """

        self._charset = charset

    @property
    def attachments(self):
        """Gets the attachments of this ReplyToAliasEmailOptions.  # noqa: E501

        List of uploaded attachments to send with the reply. Optional.  # noqa: E501

        :return: The attachments of this ReplyToAliasEmailOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._attachments

    @attachments.setter
    def attachments(self, attachments):
        """Sets the attachments of this ReplyToAliasEmailOptions.

        List of uploaded attachments to send with the reply. Optional.  # noqa: E501

        :param attachments: The attachments of this ReplyToAliasEmailOptions.  # noqa: E501
        :type: list[str]
        """

        self._attachments = attachments

    @property
    def template_variables(self):
        """Gets the template_variables of this ReplyToAliasEmailOptions.  # noqa: E501

        Template variables if using a template  # noqa: E501

        :return: The template_variables of this ReplyToAliasEmailOptions.  # noqa: E501
        :rtype: dict(str, object)
        """
        return self._template_variables

    @template_variables.setter
    def template_variables(self, template_variables):
        """Sets the template_variables of this ReplyToAliasEmailOptions.

        Template variables if using a template  # noqa: E501

        :param template_variables: The template_variables of this ReplyToAliasEmailOptions.  # noqa: E501
        :type: dict(str, object)
        """

        self._template_variables = template_variables

    @property
    def template(self):
        """Gets the template of this ReplyToAliasEmailOptions.  # noqa: E501

        Template ID to use instead of body. Will use template variable map to fill defined variable slots.  # noqa: E501

        :return: The template of this ReplyToAliasEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._template

    @template.setter
    def template(self, template):
        """Sets the template of this ReplyToAliasEmailOptions.

        Template ID to use instead of body. Will use template variable map to fill defined variable slots.  # noqa: E501

        :param template: The template of this ReplyToAliasEmailOptions.  # noqa: E501
        :type: str
        """

        self._template = template

    @property
    def send_strategy(self):
        """Gets the send_strategy of this ReplyToAliasEmailOptions.  # noqa: E501

        How an email should be sent based on its recipients  # noqa: E501

        :return: The send_strategy of this ReplyToAliasEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._send_strategy

    @send_strategy.setter
    def send_strategy(self, send_strategy):
        """Sets the send_strategy of this ReplyToAliasEmailOptions.

        How an email should be sent based on its recipients  # noqa: E501

        :param send_strategy: The send_strategy of this ReplyToAliasEmailOptions.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"SINGLE_MESSAGE"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and send_strategy not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `send_strategy` ({0}), must be one of {1}"  # noqa: E501
                .format(send_strategy, allowed_values)
            )

        self._send_strategy = send_strategy

    @property
    def custom_headers(self):
        """Gets the custom_headers of this ReplyToAliasEmailOptions.  # noqa: E501

        Optional custom headers  # noqa: E501

        :return: The custom_headers of this ReplyToAliasEmailOptions.  # noqa: E501
        :rtype: dict(str, str)
        """
        return self._custom_headers

    @custom_headers.setter
    def custom_headers(self, custom_headers):
        """Sets the custom_headers of this ReplyToAliasEmailOptions.

        Optional custom headers  # noqa: E501

        :param custom_headers: The custom_headers of this ReplyToAliasEmailOptions.  # noqa: E501
        :type: dict(str, str)
        """

        self._custom_headers = custom_headers

    @property
    def use_inbox_name(self):
        """Gets the use_inbox_name of this ReplyToAliasEmailOptions.  # noqa: E501

        Optionally use inbox name as display name for sender email address  # noqa: E501

        :return: The use_inbox_name of this ReplyToAliasEmailOptions.  # noqa: E501
        :rtype: bool
        """
        return self._use_inbox_name

    @use_inbox_name.setter
    def use_inbox_name(self, use_inbox_name):
        """Sets the use_inbox_name of this ReplyToAliasEmailOptions.

        Optionally use inbox name as display name for sender email address  # noqa: E501

        :param use_inbox_name: The use_inbox_name of this ReplyToAliasEmailOptions.  # noqa: E501
        :type: bool
        """

        self._use_inbox_name = use_inbox_name

    @property
    def html(self):
        """Gets the html of this ReplyToAliasEmailOptions.  # noqa: E501


        :return: The html of this ReplyToAliasEmailOptions.  # noqa: E501
        :rtype: bool
        """
        return self._html

    @html.setter
    def html(self, html):
        """Sets the html of this ReplyToAliasEmailOptions.


        :param html: The html of this ReplyToAliasEmailOptions.  # noqa: E501
        :type: bool
        """

        self._html = html

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ReplyToAliasEmailOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ReplyToAliasEmailOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/reply_for_sms.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ReplyForSms(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'reply': 'SentSmsDto'
    }

    attribute_map = {
        'reply': 'reply'
    }

    def __init__(self, reply=None, local_vars_configuration=None):  # noqa: E501
        """ReplyForSms - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._reply = None
        self.discriminator = None

        if reply is not None:
            self.reply = reply

    @property
    def reply(self):
        """Gets the reply of this ReplyForSms.  # noqa: E501


        :return: The reply of this ReplyForSms.  # noqa: E501
        :rtype: SentSmsDto
        """
        return self._reply

    @reply.setter
    def reply(self, reply):
        """Sets the reply of this ReplyForSms.


        :param reply: The reply of this ReplyForSms.  # noqa: E501
        :type: SentSmsDto
        """

        self._reply = reply

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ReplyForSms):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ReplyForSms):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/recipient.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class Recipient(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'raw_value': 'str',
        'email_address': 'str',
        'name': 'str'
    }

    attribute_map = {
        'raw_value': 'rawValue',
        'email_address': 'emailAddress',
        'name': 'name'
    }

    def __init__(self, raw_value=None, email_address=None, name=None, local_vars_configuration=None):  # noqa: E501
        """Recipient - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._raw_value = None
        self._email_address = None
        self._name = None
        self.discriminator = None

        self.raw_value = raw_value
        self.email_address = email_address
        self.name = name

    @property
    def raw_value(self):
        """Gets the raw_value of this Recipient.  # noqa: E501


        :return: The raw_value of this Recipient.  # noqa: E501
        :rtype: str
        """
        return self._raw_value

    @raw_value.setter
    def raw_value(self, raw_value):
        """Sets the raw_value of this Recipient.


        :param raw_value: The raw_value of this Recipient.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and raw_value is None:  # noqa: E501
            raise ValueError("Invalid value for `raw_value`, must not be `None`")  # noqa: E501

        self._raw_value = raw_value

    @property
    def email_address(self):
        """Gets the email_address of this Recipient.  # noqa: E501


        :return: The email_address of this Recipient.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this Recipient.


        :param email_address: The email_address of this Recipient.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    @property
    def name(self):
        """Gets the name of this Recipient.  # noqa: E501


        :return: The name of this Recipient.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this Recipient.


        :param name: The name of this Recipient.  # noqa: E501
        :type: str
        """

        self._name = name

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, Recipient):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, Recipient):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/raw_email_json.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class RawEmailJson(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'str'
    }

    attribute_map = {
        'content': 'content'
    }

    def __init__(self, content=None, local_vars_configuration=None):  # noqa: E501
        """RawEmailJson - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self.discriminator = None

        self.content = content

    @property
    def content(self):
        """Gets the content of this RawEmailJson.  # noqa: E501


        :return: The content of this RawEmailJson.  # noqa: E501
        :rtype: str
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this RawEmailJson.


        :param content: The content of this RawEmailJson.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and content is None:  # noqa: E501
            raise ValueError("Invalid value for `content`, must not be `None`")  # noqa: E501

        self._content = content

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, RawEmailJson):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, RawEmailJson):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/phone_plan_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PhonePlanDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'phone_country': 'str',
        'created_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'phone_country': 'phoneCountry',
        'created_at': 'createdAt'
    }

    def __init__(self, id=None, user_id=None, phone_country=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """PhonePlanDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._phone_country = None
        self._created_at = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        self.phone_country = phone_country
        self.created_at = created_at

    @property
    def id(self):
        """Gets the id of this PhonePlanDto.  # noqa: E501


        :return: The id of this PhonePlanDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this PhonePlanDto.


        :param id: The id of this PhonePlanDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this PhonePlanDto.  # noqa: E501


        :return: The user_id of this PhonePlanDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this PhonePlanDto.


        :param user_id: The user_id of this PhonePlanDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def phone_country(self):
        """Gets the phone_country of this PhonePlanDto.  # noqa: E501


        :return: The phone_country of this PhonePlanDto.  # noqa: E501
        :rtype: str
        """
        return self._phone_country

    @phone_country.setter
    def phone_country(self, phone_country):
        """Sets the phone_country of this PhonePlanDto.


        :param phone_country: The phone_country of this PhonePlanDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and phone_country is None:  # noqa: E501
            raise ValueError("Invalid value for `phone_country`, must not be `None`")  # noqa: E501
        allowed_values = ["US", "GB", "AU"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and phone_country not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `phone_country` ({0}), must be one of {1}"  # noqa: E501
                .format(phone_country, allowed_values)
            )

        self._phone_country = phone_country

    @property
    def created_at(self):
        """Gets the created_at of this PhonePlanDto.  # noqa: E501


        :return: The created_at of this PhonePlanDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this PhonePlanDto.


        :param created_at: The created_at of this PhonePlanDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PhonePlanDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PhonePlanDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/phone_number_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PhoneNumberProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'user_id': 'str',
        'phone_number': 'str',
        'phone_country': 'str',
        'id': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'user_id': 'userId',
        'phone_number': 'phoneNumber',
        'phone_country': 'phoneCountry',
        'id': 'id'
    }

    def __init__(self, created_at=None, user_id=None, phone_number=None, phone_country=None, id=None, local_vars_configuration=None):  # noqa: E501
        """PhoneNumberProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._user_id = None
        self._phone_number = None
        self._phone_country = None
        self._id = None
        self.discriminator = None

        self.created_at = created_at
        self.user_id = user_id
        self.phone_number = phone_number
        self.phone_country = phone_country
        self.id = id

    @property
    def created_at(self):
        """Gets the created_at of this PhoneNumberProjection.  # noqa: E501


        :return: The created_at of this PhoneNumberProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this PhoneNumberProjection.


        :param created_at: The created_at of this PhoneNumberProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def user_id(self):
        """Gets the user_id of this PhoneNumberProjection.  # noqa: E501


        :return: The user_id of this PhoneNumberProjection.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this PhoneNumberProjection.


        :param user_id: The user_id of this PhoneNumberProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def phone_number(self):
        """Gets the phone_number of this PhoneNumberProjection.  # noqa: E501


        :return: The phone_number of this PhoneNumberProjection.  # noqa: E501
        :rtype: str
        """
        return self._phone_number

    @phone_number.setter
    def phone_number(self, phone_number):
        """Sets the phone_number of this PhoneNumberProjection.


        :param phone_number: The phone_number of this PhoneNumberProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and phone_number is None:  # noqa: E501
            raise ValueError("Invalid value for `phone_number`, must not be `None`")  # noqa: E501

        self._phone_number = phone_number

    @property
    def phone_country(self):
        """Gets the phone_country of this PhoneNumberProjection.  # noqa: E501


        :return: The phone_country of this PhoneNumberProjection.  # noqa: E501
        :rtype: str
        """
        return self._phone_country

    @phone_country.setter
    def phone_country(self, phone_country):
        """Sets the phone_country of this PhoneNumberProjection.


        :param phone_country: The phone_country of this PhoneNumberProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and phone_country is None:  # noqa: E501
            raise ValueError("Invalid value for `phone_country`, must not be `None`")  # noqa: E501
        allowed_values = ["US", "GB", "AU"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and phone_country not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `phone_country` ({0}), must be one of {1}"  # noqa: E501
                .format(phone_country, allowed_values)
            )

        self._phone_country = phone_country

    @property
    def id(self):
        """Gets the id of this PhoneNumberProjection.  # noqa: E501


        :return: The id of this PhoneNumberProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this PhoneNumberProjection.


        :param id: The id of this PhoneNumberProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PhoneNumberProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PhoneNumberProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/phone_number_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PhoneNumberDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'compliance_address': 'str',
        'emergency_address': 'str',
        'phone_number': 'str',
        'phone_country': 'str',
        'phone_plan': 'str',
        'created_at': 'datetime',
        'updated_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'compliance_address': 'complianceAddress',
        'emergency_address': 'emergencyAddress',
        'phone_number': 'phoneNumber',
        'phone_country': 'phoneCountry',
        'phone_plan': 'phonePlan',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt'
    }

    def __init__(self, id=None, user_id=None, compliance_address=None, emergency_address=None, phone_number=None, phone_country=None, phone_plan=None, created_at=None, updated_at=None, local_vars_configuration=None):  # noqa: E501
        """PhoneNumberDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._compliance_address = None
        self._emergency_address = None
        self._phone_number = None
        self._phone_country = None
        self._phone_plan = None
        self._created_at = None
        self._updated_at = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        if compliance_address is not None:
            self.compliance_address = compliance_address
        if emergency_address is not None:
            self.emergency_address = emergency_address
        self.phone_number = phone_number
        self.phone_country = phone_country
        self.phone_plan = phone_plan
        self.created_at = created_at
        self.updated_at = updated_at

    @property
    def id(self):
        """Gets the id of this PhoneNumberDto.  # noqa: E501


        :return: The id of this PhoneNumberDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this PhoneNumberDto.


        :param id: The id of this PhoneNumberDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this PhoneNumberDto.  # noqa: E501


        :return: The user_id of this PhoneNumberDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this PhoneNumberDto.


        :param user_id: The user_id of this PhoneNumberDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def compliance_address(self):
        """Gets the compliance_address of this PhoneNumberDto.  # noqa: E501


        :return: The compliance_address of this PhoneNumberDto.  # noqa: E501
        :rtype: str
        """
        return self._compliance_address

    @compliance_address.setter
    def compliance_address(self, compliance_address):
        """Sets the compliance_address of this PhoneNumberDto.


        :param compliance_address: The compliance_address of this PhoneNumberDto.  # noqa: E501
        :type: str
        """

        self._compliance_address = compliance_address

    @property
    def emergency_address(self):
        """Gets the emergency_address of this PhoneNumberDto.  # noqa: E501


        :return: The emergency_address of this PhoneNumberDto.  # noqa: E501
        :rtype: str
        """
        return self._emergency_address

    @emergency_address.setter
    def emergency_address(self, emergency_address):
        """Sets the emergency_address of this PhoneNumberDto.


        :param emergency_address: The emergency_address of this PhoneNumberDto.  # noqa: E501
        :type: str
        """

        self._emergency_address = emergency_address

    @property
    def phone_number(self):
        """Gets the phone_number of this PhoneNumberDto.  # noqa: E501


        :return: The phone_number of this PhoneNumberDto.  # noqa: E501
        :rtype: str
        """
        return self._phone_number

    @phone_number.setter
    def phone_number(self, phone_number):
        """Sets the phone_number of this PhoneNumberDto.


        :param phone_number: The phone_number of this PhoneNumberDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and phone_number is None:  # noqa: E501
            raise ValueError("Invalid value for `phone_number`, must not be `None`")  # noqa: E501

        self._phone_number = phone_number

    @property
    def phone_country(self):
        """Gets the phone_country of this PhoneNumberDto.  # noqa: E501


        :return: The phone_country of this PhoneNumberDto.  # noqa: E501
        :rtype: str
        """
        return self._phone_country

    @phone_country.setter
    def phone_country(self, phone_country):
        """Sets the phone_country of this PhoneNumberDto.


        :param phone_country: The phone_country of this PhoneNumberDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and phone_country is None:  # noqa: E501
            raise ValueError("Invalid value for `phone_country`, must not be `None`")  # noqa: E501
        allowed_values = ["US", "GB", "AU"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and phone_country not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `phone_country` ({0}), must be one of {1}"  # noqa: E501
                .format(phone_country, allowed_values)
            )

        self._phone_country = phone_country

    @property
    def phone_plan(self):
        """Gets the phone_plan of this PhoneNumberDto.  # noqa: E501


        :return: The phone_plan of this PhoneNumberDto.  # noqa: E501
        :rtype: str
        """
        return self._phone_plan

    @phone_plan.setter
    def phone_plan(self, phone_plan):
        """Sets the phone_plan of this PhoneNumberDto.


        :param phone_plan: The phone_plan of this PhoneNumberDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and phone_plan is None:  # noqa: E501
            raise ValueError("Invalid value for `phone_plan`, must not be `None`")  # noqa: E501

        self._phone_plan = phone_plan

    @property
    def created_at(self):
        """Gets the created_at of this PhoneNumberDto.  # noqa: E501


        :return: The created_at of this PhoneNumberDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this PhoneNumberDto.


        :param created_at: The created_at of this PhoneNumberDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this PhoneNumberDto.  # noqa: E501


        :return: The updated_at of this PhoneNumberDto.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this PhoneNumberDto.


        :param updated_at: The updated_at of this PhoneNumberDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PhoneNumberDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PhoneNumberDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/pageable_object.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageableObject(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'page_number': 'int',
        'page_size': 'int',
        'unpaged': 'bool',
        'paged': 'bool',
        'offset': 'int',
        'sort': 'SortObject'
    }

    attribute_map = {
        'page_number': 'pageNumber',
        'page_size': 'pageSize',
        'unpaged': 'unpaged',
        'paged': 'paged',
        'offset': 'offset',
        'sort': 'sort'
    }

    def __init__(self, page_number=None, page_size=None, unpaged=None, paged=None, offset=None, sort=None, local_vars_configuration=None):  # noqa: E501
        """PageableObject - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._page_number = None
        self._page_size = None
        self._unpaged = None
        self._paged = None
        self._offset = None
        self._sort = None
        self.discriminator = None

        if page_number is not None:
            self.page_number = page_number
        if page_size is not None:
            self.page_size = page_size
        if unpaged is not None:
            self.unpaged = unpaged
        if paged is not None:
            self.paged = paged
        if offset is not None:
            self.offset = offset
        if sort is not None:
            self.sort = sort

    @property
    def page_number(self):
        """Gets the page_number of this PageableObject.  # noqa: E501


        :return: The page_number of this PageableObject.  # noqa: E501
        :rtype: int
        """
        return self._page_number

    @page_number.setter
    def page_number(self, page_number):
        """Sets the page_number of this PageableObject.


        :param page_number: The page_number of this PageableObject.  # noqa: E501
        :type: int
        """

        self._page_number = page_number

    @property
    def page_size(self):
        """Gets the page_size of this PageableObject.  # noqa: E501


        :return: The page_size of this PageableObject.  # noqa: E501
        :rtype: int
        """
        return self._page_size

    @page_size.setter
    def page_size(self, page_size):
        """Sets the page_size of this PageableObject.


        :param page_size: The page_size of this PageableObject.  # noqa: E501
        :type: int
        """

        self._page_size = page_size

    @property
    def unpaged(self):
        """Gets the unpaged of this PageableObject.  # noqa: E501


        :return: The unpaged of this PageableObject.  # noqa: E501
        :rtype: bool
        """
        return self._unpaged

    @unpaged.setter
    def unpaged(self, unpaged):
        """Sets the unpaged of this PageableObject.


        :param unpaged: The unpaged of this PageableObject.  # noqa: E501
        :type: bool
        """

        self._unpaged = unpaged

    @property
    def paged(self):
        """Gets the paged of this PageableObject.  # noqa: E501


        :return: The paged of this PageableObject.  # noqa: E501
        :rtype: bool
        """
        return self._paged

    @paged.setter
    def paged(self, paged):
        """Sets the paged of this PageableObject.


        :param paged: The paged of this PageableObject.  # noqa: E501
        :type: bool
        """

        self._paged = paged

    @property
    def offset(self):
        """Gets the offset of this PageableObject.  # noqa: E501


        :return: The offset of this PageableObject.  # noqa: E501
        :rtype: int
        """
        return self._offset

    @offset.setter
    def offset(self, offset):
        """Sets the offset of this PageableObject.


        :param offset: The offset of this PageableObject.  # noqa: E501
        :type: int
        """

        self._offset = offset

    @property
    def sort(self):
        """Gets the sort of this PageableObject.  # noqa: E501


        :return: The sort of this PageableObject.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageableObject.


        :param sort: The sort of this PageableObject.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageableObject):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageableObject):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_webhook_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageWebhookResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[WebhookResultDto]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageWebhookResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageWebhookResult.  # noqa: E501


        :return: The content of this PageWebhookResult.  # noqa: E501
        :rtype: list[WebhookResultDto]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageWebhookResult.


        :param content: The content of this PageWebhookResult.  # noqa: E501
        :type: list[WebhookResultDto]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageWebhookResult.  # noqa: E501


        :return: The pageable of this PageWebhookResult.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageWebhookResult.


        :param pageable: The pageable of this PageWebhookResult.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageWebhookResult.  # noqa: E501


        :return: The total_pages of this PageWebhookResult.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageWebhookResult.


        :param total_pages: The total_pages of this PageWebhookResult.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageWebhookResult.  # noqa: E501


        :return: The total_elements of this PageWebhookResult.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageWebhookResult.


        :param total_elements: The total_elements of this PageWebhookResult.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageWebhookResult.  # noqa: E501


        :return: The last of this PageWebhookResult.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageWebhookResult.


        :param last: The last of this PageWebhookResult.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageWebhookResult.  # noqa: E501


        :return: The number_of_elements of this PageWebhookResult.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageWebhookResult.


        :param number_of_elements: The number_of_elements of this PageWebhookResult.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageWebhookResult.  # noqa: E501


        :return: The first of this PageWebhookResult.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageWebhookResult.


        :param first: The first of this PageWebhookResult.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageWebhookResult.  # noqa: E501


        :return: The size of this PageWebhookResult.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageWebhookResult.


        :param size: The size of this PageWebhookResult.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageWebhookResult.  # noqa: E501


        :return: The number of this PageWebhookResult.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageWebhookResult.


        :param number: The number of this PageWebhookResult.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageWebhookResult.  # noqa: E501


        :return: The sort of this PageWebhookResult.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageWebhookResult.


        :param sort: The sort of this PageWebhookResult.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageWebhookResult.  # noqa: E501


        :return: The empty of this PageWebhookResult.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageWebhookResult.


        :param empty: The empty of this PageWebhookResult.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageWebhookResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageWebhookResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_webhook_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageWebhookProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[WebhookProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageWebhookProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageWebhookProjection.  # noqa: E501


        :return: The content of this PageWebhookProjection.  # noqa: E501
        :rtype: list[WebhookProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageWebhookProjection.


        :param content: The content of this PageWebhookProjection.  # noqa: E501
        :type: list[WebhookProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageWebhookProjection.  # noqa: E501


        :return: The pageable of this PageWebhookProjection.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageWebhookProjection.


        :param pageable: The pageable of this PageWebhookProjection.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageWebhookProjection.  # noqa: E501


        :return: The total_pages of this PageWebhookProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageWebhookProjection.


        :param total_pages: The total_pages of this PageWebhookProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageWebhookProjection.  # noqa: E501


        :return: The total_elements of this PageWebhookProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageWebhookProjection.


        :param total_elements: The total_elements of this PageWebhookProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageWebhookProjection.  # noqa: E501


        :return: The last of this PageWebhookProjection.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageWebhookProjection.


        :param last: The last of this PageWebhookProjection.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageWebhookProjection.  # noqa: E501


        :return: The number_of_elements of this PageWebhookProjection.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageWebhookProjection.


        :param number_of_elements: The number_of_elements of this PageWebhookProjection.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageWebhookProjection.  # noqa: E501


        :return: The first of this PageWebhookProjection.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageWebhookProjection.


        :param first: The first of this PageWebhookProjection.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageWebhookProjection.  # noqa: E501


        :return: The size of this PageWebhookProjection.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageWebhookProjection.


        :param size: The size of this PageWebhookProjection.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageWebhookProjection.  # noqa: E501


        :return: The number of this PageWebhookProjection.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageWebhookProjection.


        :param number: The number of this PageWebhookProjection.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageWebhookProjection.  # noqa: E501


        :return: The sort of this PageWebhookProjection.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageWebhookProjection.


        :param sort: The sort of this PageWebhookProjection.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageWebhookProjection.  # noqa: E501


        :return: The empty of this PageWebhookProjection.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageWebhookProjection.


        :param empty: The empty of this PageWebhookProjection.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageWebhookProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageWebhookProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_unknown_missed_email_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageUnknownMissedEmailProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[UnknownMissedEmailProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageUnknownMissedEmailProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageUnknownMissedEmailProjection.  # noqa: E501


        :return: The content of this PageUnknownMissedEmailProjection.  # noqa: E501
        :rtype: list[UnknownMissedEmailProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageUnknownMissedEmailProjection.


        :param content: The content of this PageUnknownMissedEmailProjection.  # noqa: E501
        :type: list[UnknownMissedEmailProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageUnknownMissedEmailProjection.  # noqa: E501


        :return: The pageable of this PageUnknownMissedEmailProjection.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageUnknownMissedEmailProjection.


        :param pageable: The pageable of this PageUnknownMissedEmailProjection.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageUnknownMissedEmailProjection.  # noqa: E501


        :return: The total_pages of this PageUnknownMissedEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageUnknownMissedEmailProjection.


        :param total_pages: The total_pages of this PageUnknownMissedEmailProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageUnknownMissedEmailProjection.  # noqa: E501


        :return: The total_elements of this PageUnknownMissedEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageUnknownMissedEmailProjection.


        :param total_elements: The total_elements of this PageUnknownMissedEmailProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageUnknownMissedEmailProjection.  # noqa: E501


        :return: The last of this PageUnknownMissedEmailProjection.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageUnknownMissedEmailProjection.


        :param last: The last of this PageUnknownMissedEmailProjection.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageUnknownMissedEmailProjection.  # noqa: E501


        :return: The number_of_elements of this PageUnknownMissedEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageUnknownMissedEmailProjection.


        :param number_of_elements: The number_of_elements of this PageUnknownMissedEmailProjection.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageUnknownMissedEmailProjection.  # noqa: E501


        :return: The first of this PageUnknownMissedEmailProjection.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageUnknownMissedEmailProjection.


        :param first: The first of this PageUnknownMissedEmailProjection.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageUnknownMissedEmailProjection.  # noqa: E501


        :return: The size of this PageUnknownMissedEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageUnknownMissedEmailProjection.


        :param size: The size of this PageUnknownMissedEmailProjection.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageUnknownMissedEmailProjection.  # noqa: E501


        :return: The number of this PageUnknownMissedEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageUnknownMissedEmailProjection.


        :param number: The number of this PageUnknownMissedEmailProjection.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageUnknownMissedEmailProjection.  # noqa: E501


        :return: The sort of this PageUnknownMissedEmailProjection.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageUnknownMissedEmailProjection.


        :param sort: The sort of this PageUnknownMissedEmailProjection.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageUnknownMissedEmailProjection.  # noqa: E501


        :return: The empty of this PageUnknownMissedEmailProjection.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageUnknownMissedEmailProjection.


        :param empty: The empty of this PageUnknownMissedEmailProjection.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageUnknownMissedEmailProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageUnknownMissedEmailProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_tracking_pixel_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageTrackingPixelProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[TrackingPixelProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageTrackingPixelProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageTrackingPixelProjection.  # noqa: E501


        :return: The content of this PageTrackingPixelProjection.  # noqa: E501
        :rtype: list[TrackingPixelProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageTrackingPixelProjection.


        :param content: The content of this PageTrackingPixelProjection.  # noqa: E501
        :type: list[TrackingPixelProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageTrackingPixelProjection.  # noqa: E501


        :return: The pageable of this PageTrackingPixelProjection.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageTrackingPixelProjection.


        :param pageable: The pageable of this PageTrackingPixelProjection.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageTrackingPixelProjection.  # noqa: E501


        :return: The total_pages of this PageTrackingPixelProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageTrackingPixelProjection.


        :param total_pages: The total_pages of this PageTrackingPixelProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageTrackingPixelProjection.  # noqa: E501


        :return: The total_elements of this PageTrackingPixelProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageTrackingPixelProjection.


        :param total_elements: The total_elements of this PageTrackingPixelProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageTrackingPixelProjection.  # noqa: E501


        :return: The last of this PageTrackingPixelProjection.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageTrackingPixelProjection.


        :param last: The last of this PageTrackingPixelProjection.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageTrackingPixelProjection.  # noqa: E501


        :return: The number_of_elements of this PageTrackingPixelProjection.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageTrackingPixelProjection.


        :param number_of_elements: The number_of_elements of this PageTrackingPixelProjection.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageTrackingPixelProjection.  # noqa: E501


        :return: The first of this PageTrackingPixelProjection.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageTrackingPixelProjection.


        :param first: The first of this PageTrackingPixelProjection.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageTrackingPixelProjection.  # noqa: E501


        :return: The size of this PageTrackingPixelProjection.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageTrackingPixelProjection.


        :param size: The size of this PageTrackingPixelProjection.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageTrackingPixelProjection.  # noqa: E501


        :return: The number of this PageTrackingPixelProjection.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageTrackingPixelProjection.


        :param number: The number of this PageTrackingPixelProjection.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageTrackingPixelProjection.  # noqa: E501


        :return: The sort of this PageTrackingPixelProjection.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageTrackingPixelProjection.


        :param sort: The sort of this PageTrackingPixelProjection.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageTrackingPixelProjection.  # noqa: E501


        :return: The empty of this PageTrackingPixelProjection.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageTrackingPixelProjection.


        :param empty: The empty of this PageTrackingPixelProjection.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageTrackingPixelProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageTrackingPixelProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_thread_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageThreadProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[ThreadProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageThreadProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageThreadProjection.  # noqa: E501


        :return: The content of this PageThreadProjection.  # noqa: E501
        :rtype: list[ThreadProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageThreadProjection.


        :param content: The content of this PageThreadProjection.  # noqa: E501
        :type: list[ThreadProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageThreadProjection.  # noqa: E501


        :return: The pageable of this PageThreadProjection.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageThreadProjection.


        :param pageable: The pageable of this PageThreadProjection.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageThreadProjection.  # noqa: E501


        :return: The total_pages of this PageThreadProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageThreadProjection.


        :param total_pages: The total_pages of this PageThreadProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageThreadProjection.  # noqa: E501


        :return: The total_elements of this PageThreadProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageThreadProjection.


        :param total_elements: The total_elements of this PageThreadProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageThreadProjection.  # noqa: E501


        :return: The last of this PageThreadProjection.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageThreadProjection.


        :param last: The last of this PageThreadProjection.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageThreadProjection.  # noqa: E501


        :return: The number_of_elements of this PageThreadProjection.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageThreadProjection.


        :param number_of_elements: The number_of_elements of this PageThreadProjection.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageThreadProjection.  # noqa: E501


        :return: The first of this PageThreadProjection.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageThreadProjection.


        :param first: The first of this PageThreadProjection.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageThreadProjection.  # noqa: E501


        :return: The size of this PageThreadProjection.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageThreadProjection.


        :param size: The size of this PageThreadProjection.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageThreadProjection.  # noqa: E501


        :return: The number of this PageThreadProjection.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageThreadProjection.


        :param number: The number of this PageThreadProjection.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageThreadProjection.  # noqa: E501


        :return: The sort of this PageThreadProjection.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageThreadProjection.


        :param sort: The sort of this PageThreadProjection.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageThreadProjection.  # noqa: E501


        :return: The empty of this PageThreadProjection.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageThreadProjection.


        :param empty: The empty of this PageThreadProjection.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageThreadProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageThreadProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_template_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageTemplateProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[TemplateProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageTemplateProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageTemplateProjection.  # noqa: E501


        :return: The content of this PageTemplateProjection.  # noqa: E501
        :rtype: list[TemplateProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageTemplateProjection.


        :param content: The content of this PageTemplateProjection.  # noqa: E501
        :type: list[TemplateProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageTemplateProjection.  # noqa: E501


        :return: The pageable of this PageTemplateProjection.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageTemplateProjection.


        :param pageable: The pageable of this PageTemplateProjection.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageTemplateProjection.  # noqa: E501


        :return: The total_pages of this PageTemplateProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageTemplateProjection.


        :param total_pages: The total_pages of this PageTemplateProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageTemplateProjection.  # noqa: E501


        :return: The total_elements of this PageTemplateProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageTemplateProjection.


        :param total_elements: The total_elements of this PageTemplateProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageTemplateProjection.  # noqa: E501


        :return: The last of this PageTemplateProjection.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageTemplateProjection.


        :param last: The last of this PageTemplateProjection.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageTemplateProjection.  # noqa: E501


        :return: The number_of_elements of this PageTemplateProjection.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageTemplateProjection.


        :param number_of_elements: The number_of_elements of this PageTemplateProjection.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageTemplateProjection.  # noqa: E501


        :return: The first of this PageTemplateProjection.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageTemplateProjection.


        :param first: The first of this PageTemplateProjection.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageTemplateProjection.  # noqa: E501


        :return: The size of this PageTemplateProjection.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageTemplateProjection.


        :param size: The size of this PageTemplateProjection.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageTemplateProjection.  # noqa: E501


        :return: The number of this PageTemplateProjection.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageTemplateProjection.


        :param number: The number of this PageTemplateProjection.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageTemplateProjection.  # noqa: E501


        :return: The sort of this PageTemplateProjection.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageTemplateProjection.


        :param sort: The sort of this PageTemplateProjection.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageTemplateProjection.  # noqa: E501


        :return: The empty of this PageTemplateProjection.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageTemplateProjection.


        :param empty: The empty of this PageTemplateProjection.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageTemplateProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageTemplateProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_sms_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageSmsProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[SmsProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageSmsProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageSmsProjection.  # noqa: E501


        :return: The content of this PageSmsProjection.  # noqa: E501
        :rtype: list[SmsProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageSmsProjection.


        :param content: The content of this PageSmsProjection.  # noqa: E501
        :type: list[SmsProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageSmsProjection.  # noqa: E501


        :return: The pageable of this PageSmsProjection.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageSmsProjection.


        :param pageable: The pageable of this PageSmsProjection.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageSmsProjection.  # noqa: E501


        :return: The total_pages of this PageSmsProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageSmsProjection.


        :param total_pages: The total_pages of this PageSmsProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageSmsProjection.  # noqa: E501


        :return: The total_elements of this PageSmsProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageSmsProjection.


        :param total_elements: The total_elements of this PageSmsProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageSmsProjection.  # noqa: E501


        :return: The last of this PageSmsProjection.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageSmsProjection.


        :param last: The last of this PageSmsProjection.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageSmsProjection.  # noqa: E501


        :return: The number_of_elements of this PageSmsProjection.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageSmsProjection.


        :param number_of_elements: The number_of_elements of this PageSmsProjection.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageSmsProjection.  # noqa: E501


        :return: The first of this PageSmsProjection.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageSmsProjection.


        :param first: The first of this PageSmsProjection.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageSmsProjection.  # noqa: E501


        :return: The size of this PageSmsProjection.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageSmsProjection.


        :param size: The size of this PageSmsProjection.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageSmsProjection.  # noqa: E501


        :return: The number of this PageSmsProjection.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageSmsProjection.


        :param number: The number of this PageSmsProjection.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageSmsProjection.  # noqa: E501


        :return: The sort of this PageSmsProjection.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageSmsProjection.


        :param sort: The sort of this PageSmsProjection.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageSmsProjection.  # noqa: E501


        :return: The empty of this PageSmsProjection.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageSmsProjection.


        :param empty: The empty of this PageSmsProjection.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageSmsProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageSmsProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_sent_email_with_queue_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageSentEmailWithQueueProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[SendWithQueueResult]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageSentEmailWithQueueProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageSentEmailWithQueueProjection.  # noqa: E501


        :return: The content of this PageSentEmailWithQueueProjection.  # noqa: E501
        :rtype: list[SendWithQueueResult]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageSentEmailWithQueueProjection.


        :param content: The content of this PageSentEmailWithQueueProjection.  # noqa: E501
        :type: list[SendWithQueueResult]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageSentEmailWithQueueProjection.  # noqa: E501


        :return: The pageable of this PageSentEmailWithQueueProjection.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageSentEmailWithQueueProjection.


        :param pageable: The pageable of this PageSentEmailWithQueueProjection.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageSentEmailWithQueueProjection.  # noqa: E501


        :return: The total_pages of this PageSentEmailWithQueueProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageSentEmailWithQueueProjection.


        :param total_pages: The total_pages of this PageSentEmailWithQueueProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageSentEmailWithQueueProjection.  # noqa: E501


        :return: The total_elements of this PageSentEmailWithQueueProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageSentEmailWithQueueProjection.


        :param total_elements: The total_elements of this PageSentEmailWithQueueProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageSentEmailWithQueueProjection.  # noqa: E501


        :return: The last of this PageSentEmailWithQueueProjection.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageSentEmailWithQueueProjection.


        :param last: The last of this PageSentEmailWithQueueProjection.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageSentEmailWithQueueProjection.  # noqa: E501


        :return: The number_of_elements of this PageSentEmailWithQueueProjection.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageSentEmailWithQueueProjection.


        :param number_of_elements: The number_of_elements of this PageSentEmailWithQueueProjection.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageSentEmailWithQueueProjection.  # noqa: E501


        :return: The first of this PageSentEmailWithQueueProjection.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageSentEmailWithQueueProjection.


        :param first: The first of this PageSentEmailWithQueueProjection.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageSentEmailWithQueueProjection.  # noqa: E501


        :return: The size of this PageSentEmailWithQueueProjection.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageSentEmailWithQueueProjection.


        :param size: The size of this PageSentEmailWithQueueProjection.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageSentEmailWithQueueProjection.  # noqa: E501


        :return: The number of this PageSentEmailWithQueueProjection.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageSentEmailWithQueueProjection.


        :param number: The number of this PageSentEmailWithQueueProjection.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageSentEmailWithQueueProjection.  # noqa: E501


        :return: The sort of this PageSentEmailWithQueueProjection.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageSentEmailWithQueueProjection.


        :param sort: The sort of this PageSentEmailWithQueueProjection.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageSentEmailWithQueueProjection.  # noqa: E501


        :return: The empty of this PageSentEmailWithQueueProjection.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageSentEmailWithQueueProjection.


        :param empty: The empty of this PageSentEmailWithQueueProjection.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageSentEmailWithQueueProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageSentEmailWithQueueProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_sent_email_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageSentEmailProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[SentEmailProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageSentEmailProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageSentEmailProjection.  # noqa: E501


        :return: The content of this PageSentEmailProjection.  # noqa: E501
        :rtype: list[SentEmailProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageSentEmailProjection.


        :param content: The content of this PageSentEmailProjection.  # noqa: E501
        :type: list[SentEmailProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageSentEmailProjection.  # noqa: E501


        :return: The pageable of this PageSentEmailProjection.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageSentEmailProjection.


        :param pageable: The pageable of this PageSentEmailProjection.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageSentEmailProjection.  # noqa: E501


        :return: The total_pages of this PageSentEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageSentEmailProjection.


        :param total_pages: The total_pages of this PageSentEmailProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageSentEmailProjection.  # noqa: E501


        :return: The total_elements of this PageSentEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageSentEmailProjection.


        :param total_elements: The total_elements of this PageSentEmailProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageSentEmailProjection.  # noqa: E501


        :return: The last of this PageSentEmailProjection.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageSentEmailProjection.


        :param last: The last of this PageSentEmailProjection.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageSentEmailProjection.  # noqa: E501


        :return: The number_of_elements of this PageSentEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageSentEmailProjection.


        :param number_of_elements: The number_of_elements of this PageSentEmailProjection.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageSentEmailProjection.  # noqa: E501


        :return: The first of this PageSentEmailProjection.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageSentEmailProjection.


        :param first: The first of this PageSentEmailProjection.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageSentEmailProjection.  # noqa: E501


        :return: The size of this PageSentEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageSentEmailProjection.


        :param size: The size of this PageSentEmailProjection.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageSentEmailProjection.  # noqa: E501


        :return: The number of this PageSentEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageSentEmailProjection.


        :param number: The number of this PageSentEmailProjection.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageSentEmailProjection.  # noqa: E501


        :return: The sort of this PageSentEmailProjection.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageSentEmailProjection.


        :param sort: The sort of this PageSentEmailProjection.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageSentEmailProjection.  # noqa: E501


        :return: The empty of this PageSentEmailProjection.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageSentEmailProjection.


        :param empty: The empty of this PageSentEmailProjection.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageSentEmailProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageSentEmailProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_scheduled_jobs.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageScheduledJobs(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[ScheduledJob]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageScheduledJobs - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageScheduledJobs.  # noqa: E501


        :return: The content of this PageScheduledJobs.  # noqa: E501
        :rtype: list[ScheduledJob]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageScheduledJobs.


        :param content: The content of this PageScheduledJobs.  # noqa: E501
        :type: list[ScheduledJob]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageScheduledJobs.  # noqa: E501


        :return: The pageable of this PageScheduledJobs.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageScheduledJobs.


        :param pageable: The pageable of this PageScheduledJobs.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageScheduledJobs.  # noqa: E501


        :return: The total_pages of this PageScheduledJobs.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageScheduledJobs.


        :param total_pages: The total_pages of this PageScheduledJobs.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageScheduledJobs.  # noqa: E501


        :return: The total_elements of this PageScheduledJobs.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageScheduledJobs.


        :param total_elements: The total_elements of this PageScheduledJobs.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageScheduledJobs.  # noqa: E501


        :return: The last of this PageScheduledJobs.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageScheduledJobs.


        :param last: The last of this PageScheduledJobs.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageScheduledJobs.  # noqa: E501


        :return: The number_of_elements of this PageScheduledJobs.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageScheduledJobs.


        :param number_of_elements: The number_of_elements of this PageScheduledJobs.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageScheduledJobs.  # noqa: E501


        :return: The first of this PageScheduledJobs.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageScheduledJobs.


        :param first: The first of this PageScheduledJobs.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageScheduledJobs.  # noqa: E501


        :return: The size of this PageScheduledJobs.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageScheduledJobs.


        :param size: The size of this PageScheduledJobs.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageScheduledJobs.  # noqa: E501


        :return: The number of this PageScheduledJobs.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageScheduledJobs.


        :param number: The number of this PageScheduledJobs.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageScheduledJobs.  # noqa: E501


        :return: The sort of this PageScheduledJobs.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageScheduledJobs.


        :param sort: The sort of this PageScheduledJobs.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageScheduledJobs.  # noqa: E501


        :return: The empty of this PageScheduledJobs.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageScheduledJobs.


        :param empty: The empty of this PageScheduledJobs.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageScheduledJobs):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageScheduledJobs):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_phone_number_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PagePhoneNumberProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[PhoneNumberProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PagePhoneNumberProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PagePhoneNumberProjection.  # noqa: E501


        :return: The content of this PagePhoneNumberProjection.  # noqa: E501
        :rtype: list[PhoneNumberProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PagePhoneNumberProjection.


        :param content: The content of this PagePhoneNumberProjection.  # noqa: E501
        :type: list[PhoneNumberProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PagePhoneNumberProjection.  # noqa: E501


        :return: The pageable of this PagePhoneNumberProjection.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PagePhoneNumberProjection.


        :param pageable: The pageable of this PagePhoneNumberProjection.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PagePhoneNumberProjection.  # noqa: E501


        :return: The total_pages of this PagePhoneNumberProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PagePhoneNumberProjection.


        :param total_pages: The total_pages of this PagePhoneNumberProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PagePhoneNumberProjection.  # noqa: E501


        :return: The total_elements of this PagePhoneNumberProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PagePhoneNumberProjection.


        :param total_elements: The total_elements of this PagePhoneNumberProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PagePhoneNumberProjection.  # noqa: E501


        :return: The last of this PagePhoneNumberProjection.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PagePhoneNumberProjection.


        :param last: The last of this PagePhoneNumberProjection.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PagePhoneNumberProjection.  # noqa: E501


        :return: The number_of_elements of this PagePhoneNumberProjection.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PagePhoneNumberProjection.


        :param number_of_elements: The number_of_elements of this PagePhoneNumberProjection.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PagePhoneNumberProjection.  # noqa: E501


        :return: The first of this PagePhoneNumberProjection.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PagePhoneNumberProjection.


        :param first: The first of this PagePhoneNumberProjection.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PagePhoneNumberProjection.  # noqa: E501


        :return: The size of this PagePhoneNumberProjection.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PagePhoneNumberProjection.


        :param size: The size of this PagePhoneNumberProjection.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PagePhoneNumberProjection.  # noqa: E501


        :return: The number of this PagePhoneNumberProjection.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PagePhoneNumberProjection.


        :param number: The number of this PagePhoneNumberProjection.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PagePhoneNumberProjection.  # noqa: E501


        :return: The sort of this PagePhoneNumberProjection.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PagePhoneNumberProjection.


        :param sort: The sort of this PagePhoneNumberProjection.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PagePhoneNumberProjection.  # noqa: E501


        :return: The empty of this PagePhoneNumberProjection.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PagePhoneNumberProjection.


        :param empty: The empty of this PagePhoneNumberProjection.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PagePhoneNumberProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PagePhoneNumberProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_organization_inbox_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageOrganizationInboxProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[OrganizationInboxProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageOrganizationInboxProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageOrganizationInboxProjection.  # noqa: E501


        :return: The content of this PageOrganizationInboxProjection.  # noqa: E501
        :rtype: list[OrganizationInboxProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageOrganizationInboxProjection.


        :param content: The content of this PageOrganizationInboxProjection.  # noqa: E501
        :type: list[OrganizationInboxProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageOrganizationInboxProjection.  # noqa: E501


        :return: The pageable of this PageOrganizationInboxProjection.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageOrganizationInboxProjection.


        :param pageable: The pageable of this PageOrganizationInboxProjection.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageOrganizationInboxProjection.  # noqa: E501


        :return: The total_pages of this PageOrganizationInboxProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageOrganizationInboxProjection.


        :param total_pages: The total_pages of this PageOrganizationInboxProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageOrganizationInboxProjection.  # noqa: E501


        :return: The total_elements of this PageOrganizationInboxProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageOrganizationInboxProjection.


        :param total_elements: The total_elements of this PageOrganizationInboxProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageOrganizationInboxProjection.  # noqa: E501


        :return: The last of this PageOrganizationInboxProjection.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageOrganizationInboxProjection.


        :param last: The last of this PageOrganizationInboxProjection.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageOrganizationInboxProjection.  # noqa: E501


        :return: The number_of_elements of this PageOrganizationInboxProjection.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageOrganizationInboxProjection.


        :param number_of_elements: The number_of_elements of this PageOrganizationInboxProjection.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageOrganizationInboxProjection.  # noqa: E501


        :return: The first of this PageOrganizationInboxProjection.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageOrganizationInboxProjection.


        :param first: The first of this PageOrganizationInboxProjection.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageOrganizationInboxProjection.  # noqa: E501


        :return: The size of this PageOrganizationInboxProjection.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageOrganizationInboxProjection.


        :param size: The size of this PageOrganizationInboxProjection.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageOrganizationInboxProjection.  # noqa: E501


        :return: The number of this PageOrganizationInboxProjection.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageOrganizationInboxProjection.


        :param number: The number of this PageOrganizationInboxProjection.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageOrganizationInboxProjection.  # noqa: E501


        :return: The sort of this PageOrganizationInboxProjection.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageOrganizationInboxProjection.


        :param sort: The sort of this PageOrganizationInboxProjection.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageOrganizationInboxProjection.  # noqa: E501


        :return: The empty of this PageOrganizationInboxProjection.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageOrganizationInboxProjection.


        :param empty: The empty of this PageOrganizationInboxProjection.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageOrganizationInboxProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageOrganizationInboxProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_missed_email_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageMissedEmailProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[MissedEmailProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageMissedEmailProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageMissedEmailProjection.  # noqa: E501


        :return: The content of this PageMissedEmailProjection.  # noqa: E501
        :rtype: list[MissedEmailProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageMissedEmailProjection.


        :param content: The content of this PageMissedEmailProjection.  # noqa: E501
        :type: list[MissedEmailProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageMissedEmailProjection.  # noqa: E501


        :return: The pageable of this PageMissedEmailProjection.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageMissedEmailProjection.


        :param pageable: The pageable of this PageMissedEmailProjection.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageMissedEmailProjection.  # noqa: E501


        :return: The total_pages of this PageMissedEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageMissedEmailProjection.


        :param total_pages: The total_pages of this PageMissedEmailProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageMissedEmailProjection.  # noqa: E501


        :return: The total_elements of this PageMissedEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageMissedEmailProjection.


        :param total_elements: The total_elements of this PageMissedEmailProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageMissedEmailProjection.  # noqa: E501


        :return: The last of this PageMissedEmailProjection.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageMissedEmailProjection.


        :param last: The last of this PageMissedEmailProjection.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageMissedEmailProjection.  # noqa: E501


        :return: The number_of_elements of this PageMissedEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageMissedEmailProjection.


        :param number_of_elements: The number_of_elements of this PageMissedEmailProjection.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageMissedEmailProjection.  # noqa: E501


        :return: The first of this PageMissedEmailProjection.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageMissedEmailProjection.


        :param first: The first of this PageMissedEmailProjection.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageMissedEmailProjection.  # noqa: E501


        :return: The size of this PageMissedEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageMissedEmailProjection.


        :param size: The size of this PageMissedEmailProjection.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageMissedEmailProjection.  # noqa: E501


        :return: The number of this PageMissedEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageMissedEmailProjection.


        :param number: The number of this PageMissedEmailProjection.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageMissedEmailProjection.  # noqa: E501


        :return: The sort of this PageMissedEmailProjection.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageMissedEmailProjection.


        :param sort: The sort of this PageMissedEmailProjection.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageMissedEmailProjection.  # noqa: E501


        :return: The empty of this PageMissedEmailProjection.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageMissedEmailProjection.


        :param empty: The empty of this PageMissedEmailProjection.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageMissedEmailProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageMissedEmailProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_list_unsubscribe_recipients.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageListUnsubscribeRecipients(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[ListUnsubscribeRecipientProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageListUnsubscribeRecipients - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageListUnsubscribeRecipients.  # noqa: E501


        :return: The content of this PageListUnsubscribeRecipients.  # noqa: E501
        :rtype: list[ListUnsubscribeRecipientProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageListUnsubscribeRecipients.


        :param content: The content of this PageListUnsubscribeRecipients.  # noqa: E501
        :type: list[ListUnsubscribeRecipientProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageListUnsubscribeRecipients.  # noqa: E501


        :return: The pageable of this PageListUnsubscribeRecipients.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageListUnsubscribeRecipients.


        :param pageable: The pageable of this PageListUnsubscribeRecipients.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageListUnsubscribeRecipients.  # noqa: E501


        :return: The total_pages of this PageListUnsubscribeRecipients.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageListUnsubscribeRecipients.


        :param total_pages: The total_pages of this PageListUnsubscribeRecipients.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageListUnsubscribeRecipients.  # noqa: E501


        :return: The total_elements of this PageListUnsubscribeRecipients.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageListUnsubscribeRecipients.


        :param total_elements: The total_elements of this PageListUnsubscribeRecipients.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageListUnsubscribeRecipients.  # noqa: E501


        :return: The last of this PageListUnsubscribeRecipients.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageListUnsubscribeRecipients.


        :param last: The last of this PageListUnsubscribeRecipients.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageListUnsubscribeRecipients.  # noqa: E501


        :return: The number_of_elements of this PageListUnsubscribeRecipients.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageListUnsubscribeRecipients.


        :param number_of_elements: The number_of_elements of this PageListUnsubscribeRecipients.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageListUnsubscribeRecipients.  # noqa: E501


        :return: The first of this PageListUnsubscribeRecipients.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageListUnsubscribeRecipients.


        :param first: The first of this PageListUnsubscribeRecipients.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageListUnsubscribeRecipients.  # noqa: E501


        :return: The size of this PageListUnsubscribeRecipients.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageListUnsubscribeRecipients.


        :param size: The size of this PageListUnsubscribeRecipients.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageListUnsubscribeRecipients.  # noqa: E501


        :return: The number of this PageListUnsubscribeRecipients.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageListUnsubscribeRecipients.


        :param number: The number of this PageListUnsubscribeRecipients.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageListUnsubscribeRecipients.  # noqa: E501


        :return: The sort of this PageListUnsubscribeRecipients.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageListUnsubscribeRecipients.


        :param sort: The sort of this PageListUnsubscribeRecipients.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageListUnsubscribeRecipients.  # noqa: E501


        :return: The empty of this PageListUnsubscribeRecipients.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageListUnsubscribeRecipients.


        :param empty: The empty of this PageListUnsubscribeRecipients.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageListUnsubscribeRecipients):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageListUnsubscribeRecipients):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_inbox_ruleset_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageInboxRulesetDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[InboxRulesetDto]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageInboxRulesetDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageInboxRulesetDto.  # noqa: E501


        :return: The content of this PageInboxRulesetDto.  # noqa: E501
        :rtype: list[InboxRulesetDto]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageInboxRulesetDto.


        :param content: The content of this PageInboxRulesetDto.  # noqa: E501
        :type: list[InboxRulesetDto]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageInboxRulesetDto.  # noqa: E501


        :return: The pageable of this PageInboxRulesetDto.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageInboxRulesetDto.


        :param pageable: The pageable of this PageInboxRulesetDto.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageInboxRulesetDto.  # noqa: E501


        :return: The total_pages of this PageInboxRulesetDto.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageInboxRulesetDto.


        :param total_pages: The total_pages of this PageInboxRulesetDto.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageInboxRulesetDto.  # noqa: E501


        :return: The total_elements of this PageInboxRulesetDto.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageInboxRulesetDto.


        :param total_elements: The total_elements of this PageInboxRulesetDto.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageInboxRulesetDto.  # noqa: E501


        :return: The last of this PageInboxRulesetDto.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageInboxRulesetDto.


        :param last: The last of this PageInboxRulesetDto.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageInboxRulesetDto.  # noqa: E501


        :return: The number_of_elements of this PageInboxRulesetDto.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageInboxRulesetDto.


        :param number_of_elements: The number_of_elements of this PageInboxRulesetDto.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageInboxRulesetDto.  # noqa: E501


        :return: The first of this PageInboxRulesetDto.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageInboxRulesetDto.


        :param first: The first of this PageInboxRulesetDto.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageInboxRulesetDto.  # noqa: E501


        :return: The size of this PageInboxRulesetDto.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageInboxRulesetDto.


        :param size: The size of this PageInboxRulesetDto.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageInboxRulesetDto.  # noqa: E501


        :return: The number of this PageInboxRulesetDto.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageInboxRulesetDto.


        :param number: The number of this PageInboxRulesetDto.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageInboxRulesetDto.  # noqa: E501


        :return: The sort of this PageInboxRulesetDto.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageInboxRulesetDto.


        :param sort: The sort of this PageInboxRulesetDto.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageInboxRulesetDto.  # noqa: E501


        :return: The empty of this PageInboxRulesetDto.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageInboxRulesetDto.


        :param empty: The empty of this PageInboxRulesetDto.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageInboxRulesetDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageInboxRulesetDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_inbox_replier_events.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageInboxReplierEvents(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[InboxReplierEventProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageInboxReplierEvents - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageInboxReplierEvents.  # noqa: E501


        :return: The content of this PageInboxReplierEvents.  # noqa: E501
        :rtype: list[InboxReplierEventProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageInboxReplierEvents.


        :param content: The content of this PageInboxReplierEvents.  # noqa: E501
        :type: list[InboxReplierEventProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageInboxReplierEvents.  # noqa: E501


        :return: The pageable of this PageInboxReplierEvents.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageInboxReplierEvents.


        :param pageable: The pageable of this PageInboxReplierEvents.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageInboxReplierEvents.  # noqa: E501


        :return: The total_pages of this PageInboxReplierEvents.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageInboxReplierEvents.


        :param total_pages: The total_pages of this PageInboxReplierEvents.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageInboxReplierEvents.  # noqa: E501


        :return: The total_elements of this PageInboxReplierEvents.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageInboxReplierEvents.


        :param total_elements: The total_elements of this PageInboxReplierEvents.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageInboxReplierEvents.  # noqa: E501


        :return: The last of this PageInboxReplierEvents.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageInboxReplierEvents.


        :param last: The last of this PageInboxReplierEvents.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageInboxReplierEvents.  # noqa: E501


        :return: The number_of_elements of this PageInboxReplierEvents.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageInboxReplierEvents.


        :param number_of_elements: The number_of_elements of this PageInboxReplierEvents.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageInboxReplierEvents.  # noqa: E501


        :return: The first of this PageInboxReplierEvents.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageInboxReplierEvents.


        :param first: The first of this PageInboxReplierEvents.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageInboxReplierEvents.  # noqa: E501


        :return: The size of this PageInboxReplierEvents.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageInboxReplierEvents.


        :param size: The size of this PageInboxReplierEvents.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageInboxReplierEvents.  # noqa: E501


        :return: The number of this PageInboxReplierEvents.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageInboxReplierEvents.


        :param number: The number of this PageInboxReplierEvents.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageInboxReplierEvents.  # noqa: E501


        :return: The sort of this PageInboxReplierEvents.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageInboxReplierEvents.


        :param sort: The sort of this PageInboxReplierEvents.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageInboxReplierEvents.  # noqa: E501


        :return: The empty of this PageInboxReplierEvents.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageInboxReplierEvents.


        :param empty: The empty of this PageInboxReplierEvents.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageInboxReplierEvents):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageInboxReplierEvents):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_inbox_replier_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageInboxReplierDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[InboxReplierDto]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageInboxReplierDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageInboxReplierDto.  # noqa: E501


        :return: The content of this PageInboxReplierDto.  # noqa: E501
        :rtype: list[InboxReplierDto]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageInboxReplierDto.


        :param content: The content of this PageInboxReplierDto.  # noqa: E501
        :type: list[InboxReplierDto]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageInboxReplierDto.  # noqa: E501


        :return: The pageable of this PageInboxReplierDto.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageInboxReplierDto.


        :param pageable: The pageable of this PageInboxReplierDto.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageInboxReplierDto.  # noqa: E501


        :return: The total_pages of this PageInboxReplierDto.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageInboxReplierDto.


        :param total_pages: The total_pages of this PageInboxReplierDto.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageInboxReplierDto.  # noqa: E501


        :return: The total_elements of this PageInboxReplierDto.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageInboxReplierDto.


        :param total_elements: The total_elements of this PageInboxReplierDto.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageInboxReplierDto.  # noqa: E501


        :return: The last of this PageInboxReplierDto.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageInboxReplierDto.


        :param last: The last of this PageInboxReplierDto.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageInboxReplierDto.  # noqa: E501


        :return: The number_of_elements of this PageInboxReplierDto.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageInboxReplierDto.


        :param number_of_elements: The number_of_elements of this PageInboxReplierDto.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageInboxReplierDto.  # noqa: E501


        :return: The first of this PageInboxReplierDto.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageInboxReplierDto.


        :param first: The first of this PageInboxReplierDto.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageInboxReplierDto.  # noqa: E501


        :return: The size of this PageInboxReplierDto.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageInboxReplierDto.


        :param size: The size of this PageInboxReplierDto.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageInboxReplierDto.  # noqa: E501


        :return: The number of this PageInboxReplierDto.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageInboxReplierDto.


        :param number: The number of this PageInboxReplierDto.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageInboxReplierDto.  # noqa: E501


        :return: The sort of this PageInboxReplierDto.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageInboxReplierDto.


        :param sort: The sort of this PageInboxReplierDto.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageInboxReplierDto.  # noqa: E501


        :return: The empty of this PageInboxReplierDto.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageInboxReplierDto.


        :param empty: The empty of this PageInboxReplierDto.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageInboxReplierDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageInboxReplierDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_inbox_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageInboxProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[InboxPreview]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageInboxProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageInboxProjection.  # noqa: E501


        :return: The content of this PageInboxProjection.  # noqa: E501
        :rtype: list[InboxPreview]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageInboxProjection.


        :param content: The content of this PageInboxProjection.  # noqa: E501
        :type: list[InboxPreview]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageInboxProjection.  # noqa: E501


        :return: The pageable of this PageInboxProjection.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageInboxProjection.


        :param pageable: The pageable of this PageInboxProjection.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageInboxProjection.  # noqa: E501


        :return: The total_pages of this PageInboxProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageInboxProjection.


        :param total_pages: The total_pages of this PageInboxProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageInboxProjection.  # noqa: E501


        :return: The total_elements of this PageInboxProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageInboxProjection.


        :param total_elements: The total_elements of this PageInboxProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageInboxProjection.  # noqa: E501


        :return: The last of this PageInboxProjection.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageInboxProjection.


        :param last: The last of this PageInboxProjection.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageInboxProjection.  # noqa: E501


        :return: The number_of_elements of this PageInboxProjection.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageInboxProjection.


        :param number_of_elements: The number_of_elements of this PageInboxProjection.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageInboxProjection.  # noqa: E501


        :return: The first of this PageInboxProjection.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageInboxProjection.


        :param first: The first of this PageInboxProjection.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageInboxProjection.  # noqa: E501


        :return: The size of this PageInboxProjection.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageInboxProjection.


        :param size: The size of this PageInboxProjection.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageInboxProjection.  # noqa: E501


        :return: The number of this PageInboxProjection.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageInboxProjection.


        :param number: The number of this PageInboxProjection.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageInboxProjection.  # noqa: E501


        :return: The sort of this PageInboxProjection.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageInboxProjection.


        :param sort: The sort of this PageInboxProjection.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageInboxProjection.  # noqa: E501


        :return: The empty of this PageInboxProjection.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageInboxProjection.


        :param empty: The empty of this PageInboxProjection.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageInboxProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageInboxProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_inbox_forwarder_events.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageInboxForwarderEvents(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[InboxForwarderEventProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageInboxForwarderEvents - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageInboxForwarderEvents.  # noqa: E501


        :return: The content of this PageInboxForwarderEvents.  # noqa: E501
        :rtype: list[InboxForwarderEventProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageInboxForwarderEvents.


        :param content: The content of this PageInboxForwarderEvents.  # noqa: E501
        :type: list[InboxForwarderEventProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageInboxForwarderEvents.  # noqa: E501


        :return: The pageable of this PageInboxForwarderEvents.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageInboxForwarderEvents.


        :param pageable: The pageable of this PageInboxForwarderEvents.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageInboxForwarderEvents.  # noqa: E501


        :return: The total_pages of this PageInboxForwarderEvents.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageInboxForwarderEvents.


        :param total_pages: The total_pages of this PageInboxForwarderEvents.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageInboxForwarderEvents.  # noqa: E501


        :return: The total_elements of this PageInboxForwarderEvents.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageInboxForwarderEvents.


        :param total_elements: The total_elements of this PageInboxForwarderEvents.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageInboxForwarderEvents.  # noqa: E501


        :return: The last of this PageInboxForwarderEvents.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageInboxForwarderEvents.


        :param last: The last of this PageInboxForwarderEvents.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageInboxForwarderEvents.  # noqa: E501


        :return: The number_of_elements of this PageInboxForwarderEvents.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageInboxForwarderEvents.


        :param number_of_elements: The number_of_elements of this PageInboxForwarderEvents.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageInboxForwarderEvents.  # noqa: E501


        :return: The first of this PageInboxForwarderEvents.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageInboxForwarderEvents.


        :param first: The first of this PageInboxForwarderEvents.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageInboxForwarderEvents.  # noqa: E501


        :return: The size of this PageInboxForwarderEvents.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageInboxForwarderEvents.


        :param size: The size of this PageInboxForwarderEvents.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageInboxForwarderEvents.  # noqa: E501


        :return: The number of this PageInboxForwarderEvents.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageInboxForwarderEvents.


        :param number: The number of this PageInboxForwarderEvents.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageInboxForwarderEvents.  # noqa: E501


        :return: The sort of this PageInboxForwarderEvents.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageInboxForwarderEvents.


        :param sort: The sort of this PageInboxForwarderEvents.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageInboxForwarderEvents.  # noqa: E501


        :return: The empty of this PageInboxForwarderEvents.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageInboxForwarderEvents.


        :param empty: The empty of this PageInboxForwarderEvents.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageInboxForwarderEvents):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageInboxForwarderEvents):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_inbox_forwarder_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageInboxForwarderDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[InboxForwarderDto]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageInboxForwarderDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageInboxForwarderDto.  # noqa: E501


        :return: The content of this PageInboxForwarderDto.  # noqa: E501
        :rtype: list[InboxForwarderDto]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageInboxForwarderDto.


        :param content: The content of this PageInboxForwarderDto.  # noqa: E501
        :type: list[InboxForwarderDto]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageInboxForwarderDto.  # noqa: E501


        :return: The pageable of this PageInboxForwarderDto.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageInboxForwarderDto.


        :param pageable: The pageable of this PageInboxForwarderDto.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageInboxForwarderDto.  # noqa: E501


        :return: The total_pages of this PageInboxForwarderDto.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageInboxForwarderDto.


        :param total_pages: The total_pages of this PageInboxForwarderDto.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageInboxForwarderDto.  # noqa: E501


        :return: The total_elements of this PageInboxForwarderDto.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageInboxForwarderDto.


        :param total_elements: The total_elements of this PageInboxForwarderDto.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageInboxForwarderDto.  # noqa: E501


        :return: The last of this PageInboxForwarderDto.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageInboxForwarderDto.


        :param last: The last of this PageInboxForwarderDto.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageInboxForwarderDto.  # noqa: E501


        :return: The number_of_elements of this PageInboxForwarderDto.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageInboxForwarderDto.


        :param number_of_elements: The number_of_elements of this PageInboxForwarderDto.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageInboxForwarderDto.  # noqa: E501


        :return: The first of this PageInboxForwarderDto.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageInboxForwarderDto.


        :param first: The first of this PageInboxForwarderDto.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageInboxForwarderDto.  # noqa: E501


        :return: The size of this PageInboxForwarderDto.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageInboxForwarderDto.


        :param size: The size of this PageInboxForwarderDto.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageInboxForwarderDto.  # noqa: E501


        :return: The number of this PageInboxForwarderDto.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageInboxForwarderDto.


        :param number: The number of this PageInboxForwarderDto.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageInboxForwarderDto.  # noqa: E501


        :return: The sort of this PageInboxForwarderDto.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageInboxForwarderDto.


        :param sort: The sort of this PageInboxForwarderDto.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageInboxForwarderDto.  # noqa: E501


        :return: The empty of this PageInboxForwarderDto.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageInboxForwarderDto.


        :param empty: The empty of this PageInboxForwarderDto.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageInboxForwarderDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageInboxForwarderDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_group_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageGroupProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[GroupProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageGroupProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageGroupProjection.  # noqa: E501


        :return: The content of this PageGroupProjection.  # noqa: E501
        :rtype: list[GroupProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageGroupProjection.


        :param content: The content of this PageGroupProjection.  # noqa: E501
        :type: list[GroupProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageGroupProjection.  # noqa: E501


        :return: The pageable of this PageGroupProjection.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageGroupProjection.


        :param pageable: The pageable of this PageGroupProjection.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageGroupProjection.  # noqa: E501


        :return: The total_pages of this PageGroupProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageGroupProjection.


        :param total_pages: The total_pages of this PageGroupProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageGroupProjection.  # noqa: E501


        :return: The total_elements of this PageGroupProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageGroupProjection.


        :param total_elements: The total_elements of this PageGroupProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageGroupProjection.  # noqa: E501


        :return: The last of this PageGroupProjection.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageGroupProjection.


        :param last: The last of this PageGroupProjection.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageGroupProjection.  # noqa: E501


        :return: The number_of_elements of this PageGroupProjection.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageGroupProjection.


        :param number_of_elements: The number_of_elements of this PageGroupProjection.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageGroupProjection.  # noqa: E501


        :return: The first of this PageGroupProjection.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageGroupProjection.


        :param first: The first of this PageGroupProjection.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageGroupProjection.  # noqa: E501


        :return: The size of this PageGroupProjection.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageGroupProjection.


        :param size: The size of this PageGroupProjection.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageGroupProjection.  # noqa: E501


        :return: The number of this PageGroupProjection.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageGroupProjection.


        :param number: The number of this PageGroupProjection.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageGroupProjection.  # noqa: E501


        :return: The sort of this PageGroupProjection.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageGroupProjection.


        :param sort: The sort of this PageGroupProjection.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageGroupProjection.  # noqa: E501


        :return: The empty of this PageGroupProjection.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageGroupProjection.


        :param empty: The empty of this PageGroupProjection.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageGroupProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageGroupProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_expired_inbox_record_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageExpiredInboxRecordProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[ExpiredInboxRecordProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageExpiredInboxRecordProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageExpiredInboxRecordProjection.  # noqa: E501


        :return: The content of this PageExpiredInboxRecordProjection.  # noqa: E501
        :rtype: list[ExpiredInboxRecordProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageExpiredInboxRecordProjection.


        :param content: The content of this PageExpiredInboxRecordProjection.  # noqa: E501
        :type: list[ExpiredInboxRecordProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageExpiredInboxRecordProjection.  # noqa: E501


        :return: The pageable of this PageExpiredInboxRecordProjection.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageExpiredInboxRecordProjection.


        :param pageable: The pageable of this PageExpiredInboxRecordProjection.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageExpiredInboxRecordProjection.  # noqa: E501


        :return: The total_pages of this PageExpiredInboxRecordProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageExpiredInboxRecordProjection.


        :param total_pages: The total_pages of this PageExpiredInboxRecordProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageExpiredInboxRecordProjection.  # noqa: E501


        :return: The total_elements of this PageExpiredInboxRecordProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageExpiredInboxRecordProjection.


        :param total_elements: The total_elements of this PageExpiredInboxRecordProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageExpiredInboxRecordProjection.  # noqa: E501


        :return: The last of this PageExpiredInboxRecordProjection.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageExpiredInboxRecordProjection.


        :param last: The last of this PageExpiredInboxRecordProjection.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageExpiredInboxRecordProjection.  # noqa: E501


        :return: The number_of_elements of this PageExpiredInboxRecordProjection.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageExpiredInboxRecordProjection.


        :param number_of_elements: The number_of_elements of this PageExpiredInboxRecordProjection.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageExpiredInboxRecordProjection.  # noqa: E501


        :return: The first of this PageExpiredInboxRecordProjection.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageExpiredInboxRecordProjection.


        :param first: The first of this PageExpiredInboxRecordProjection.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageExpiredInboxRecordProjection.  # noqa: E501


        :return: The size of this PageExpiredInboxRecordProjection.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageExpiredInboxRecordProjection.


        :param size: The size of this PageExpiredInboxRecordProjection.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageExpiredInboxRecordProjection.  # noqa: E501


        :return: The number of this PageExpiredInboxRecordProjection.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageExpiredInboxRecordProjection.


        :param number: The number of this PageExpiredInboxRecordProjection.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageExpiredInboxRecordProjection.  # noqa: E501


        :return: The sort of this PageExpiredInboxRecordProjection.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageExpiredInboxRecordProjection.


        :param sort: The sort of this PageExpiredInboxRecordProjection.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageExpiredInboxRecordProjection.  # noqa: E501


        :return: The empty of this PageExpiredInboxRecordProjection.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageExpiredInboxRecordProjection.


        :param empty: The empty of this PageExpiredInboxRecordProjection.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageExpiredInboxRecordProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageExpiredInboxRecordProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_email_validation_request.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageEmailValidationRequest(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[EmailValidationRequestDto]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageEmailValidationRequest - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageEmailValidationRequest.  # noqa: E501


        :return: The content of this PageEmailValidationRequest.  # noqa: E501
        :rtype: list[EmailValidationRequestDto]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageEmailValidationRequest.


        :param content: The content of this PageEmailValidationRequest.  # noqa: E501
        :type: list[EmailValidationRequestDto]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageEmailValidationRequest.  # noqa: E501


        :return: The pageable of this PageEmailValidationRequest.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageEmailValidationRequest.


        :param pageable: The pageable of this PageEmailValidationRequest.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageEmailValidationRequest.  # noqa: E501


        :return: The total_pages of this PageEmailValidationRequest.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageEmailValidationRequest.


        :param total_pages: The total_pages of this PageEmailValidationRequest.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageEmailValidationRequest.  # noqa: E501


        :return: The total_elements of this PageEmailValidationRequest.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageEmailValidationRequest.


        :param total_elements: The total_elements of this PageEmailValidationRequest.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageEmailValidationRequest.  # noqa: E501


        :return: The last of this PageEmailValidationRequest.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageEmailValidationRequest.


        :param last: The last of this PageEmailValidationRequest.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageEmailValidationRequest.  # noqa: E501


        :return: The number_of_elements of this PageEmailValidationRequest.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageEmailValidationRequest.


        :param number_of_elements: The number_of_elements of this PageEmailValidationRequest.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageEmailValidationRequest.  # noqa: E501


        :return: The first of this PageEmailValidationRequest.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageEmailValidationRequest.


        :param first: The first of this PageEmailValidationRequest.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageEmailValidationRequest.  # noqa: E501


        :return: The size of this PageEmailValidationRequest.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageEmailValidationRequest.


        :param size: The size of this PageEmailValidationRequest.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageEmailValidationRequest.  # noqa: E501


        :return: The number of this PageEmailValidationRequest.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageEmailValidationRequest.


        :param number: The number of this PageEmailValidationRequest.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageEmailValidationRequest.  # noqa: E501


        :return: The sort of this PageEmailValidationRequest.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageEmailValidationRequest.


        :param sort: The sort of this PageEmailValidationRequest.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageEmailValidationRequest.  # noqa: E501


        :return: The empty of this PageEmailValidationRequest.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageEmailValidationRequest.


        :param empty: The empty of this PageEmailValidationRequest.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageEmailValidationRequest):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageEmailValidationRequest):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_email_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageEmailProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[EmailProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageEmailProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageEmailProjection.  # noqa: E501


        :return: The content of this PageEmailProjection.  # noqa: E501
        :rtype: list[EmailProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageEmailProjection.


        :param content: The content of this PageEmailProjection.  # noqa: E501
        :type: list[EmailProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageEmailProjection.  # noqa: E501


        :return: The pageable of this PageEmailProjection.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageEmailProjection.


        :param pageable: The pageable of this PageEmailProjection.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageEmailProjection.  # noqa: E501


        :return: The total_pages of this PageEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageEmailProjection.


        :param total_pages: The total_pages of this PageEmailProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageEmailProjection.  # noqa: E501


        :return: The total_elements of this PageEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageEmailProjection.


        :param total_elements: The total_elements of this PageEmailProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageEmailProjection.  # noqa: E501


        :return: The last of this PageEmailProjection.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageEmailProjection.


        :param last: The last of this PageEmailProjection.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageEmailProjection.  # noqa: E501


        :return: The number_of_elements of this PageEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageEmailProjection.


        :param number_of_elements: The number_of_elements of this PageEmailProjection.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageEmailProjection.  # noqa: E501


        :return: The first of this PageEmailProjection.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageEmailProjection.


        :param first: The first of this PageEmailProjection.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageEmailProjection.  # noqa: E501


        :return: The size of this PageEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageEmailProjection.


        :param size: The size of this PageEmailProjection.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageEmailProjection.  # noqa: E501


        :return: The number of this PageEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageEmailProjection.


        :param number: The number of this PageEmailProjection.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageEmailProjection.  # noqa: E501


        :return: The sort of this PageEmailProjection.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageEmailProjection.


        :param sort: The sort of this PageEmailProjection.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageEmailProjection.  # noqa: E501


        :return: The empty of this PageEmailProjection.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageEmailProjection.


        :param empty: The empty of this PageEmailProjection.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageEmailProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageEmailProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_email_preview.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageEmailPreview(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[EmailPreview]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageEmailPreview - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageEmailPreview.  # noqa: E501


        :return: The content of this PageEmailPreview.  # noqa: E501
        :rtype: list[EmailPreview]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageEmailPreview.


        :param content: The content of this PageEmailPreview.  # noqa: E501
        :type: list[EmailPreview]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageEmailPreview.  # noqa: E501


        :return: The pageable of this PageEmailPreview.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageEmailPreview.


        :param pageable: The pageable of this PageEmailPreview.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageEmailPreview.  # noqa: E501


        :return: The total_pages of this PageEmailPreview.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageEmailPreview.


        :param total_pages: The total_pages of this PageEmailPreview.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageEmailPreview.  # noqa: E501


        :return: The total_elements of this PageEmailPreview.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageEmailPreview.


        :param total_elements: The total_elements of this PageEmailPreview.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageEmailPreview.  # noqa: E501


        :return: The last of this PageEmailPreview.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageEmailPreview.


        :param last: The last of this PageEmailPreview.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageEmailPreview.  # noqa: E501


        :return: The number_of_elements of this PageEmailPreview.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageEmailPreview.


        :param number_of_elements: The number_of_elements of this PageEmailPreview.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageEmailPreview.  # noqa: E501


        :return: The first of this PageEmailPreview.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageEmailPreview.


        :param first: The first of this PageEmailPreview.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageEmailPreview.  # noqa: E501


        :return: The size of this PageEmailPreview.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageEmailPreview.


        :param size: The size of this PageEmailPreview.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageEmailPreview.  # noqa: E501


        :return: The number of this PageEmailPreview.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageEmailPreview.


        :param number: The number of this PageEmailPreview.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageEmailPreview.  # noqa: E501


        :return: The sort of this PageEmailPreview.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageEmailPreview.


        :param sort: The sort of this PageEmailPreview.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageEmailPreview.  # noqa: E501


        :return: The empty of this PageEmailPreview.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageEmailPreview.


        :param empty: The empty of this PageEmailPreview.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageEmailPreview):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageEmailPreview):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_delivery_status.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageDeliveryStatus(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[DeliveryStatusDto]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageDeliveryStatus - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageDeliveryStatus.  # noqa: E501


        :return: The content of this PageDeliveryStatus.  # noqa: E501
        :rtype: list[DeliveryStatusDto]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageDeliveryStatus.


        :param content: The content of this PageDeliveryStatus.  # noqa: E501
        :type: list[DeliveryStatusDto]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageDeliveryStatus.  # noqa: E501


        :return: The pageable of this PageDeliveryStatus.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageDeliveryStatus.


        :param pageable: The pageable of this PageDeliveryStatus.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageDeliveryStatus.  # noqa: E501


        :return: The total_pages of this PageDeliveryStatus.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageDeliveryStatus.


        :param total_pages: The total_pages of this PageDeliveryStatus.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageDeliveryStatus.  # noqa: E501


        :return: The total_elements of this PageDeliveryStatus.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageDeliveryStatus.


        :param total_elements: The total_elements of this PageDeliveryStatus.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageDeliveryStatus.  # noqa: E501


        :return: The last of this PageDeliveryStatus.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageDeliveryStatus.


        :param last: The last of this PageDeliveryStatus.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageDeliveryStatus.  # noqa: E501


        :return: The number_of_elements of this PageDeliveryStatus.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageDeliveryStatus.


        :param number_of_elements: The number_of_elements of this PageDeliveryStatus.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageDeliveryStatus.  # noqa: E501


        :return: The first of this PageDeliveryStatus.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageDeliveryStatus.


        :param first: The first of this PageDeliveryStatus.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageDeliveryStatus.  # noqa: E501


        :return: The size of this PageDeliveryStatus.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageDeliveryStatus.


        :param size: The size of this PageDeliveryStatus.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageDeliveryStatus.  # noqa: E501


        :return: The number of this PageDeliveryStatus.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageDeliveryStatus.


        :param number: The number of this PageDeliveryStatus.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageDeliveryStatus.  # noqa: E501


        :return: The sort of this PageDeliveryStatus.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageDeliveryStatus.


        :param sort: The sort of this PageDeliveryStatus.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageDeliveryStatus.  # noqa: E501


        :return: The empty of this PageDeliveryStatus.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageDeliveryStatus.


        :param empty: The empty of this PageDeliveryStatus.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageDeliveryStatus):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageDeliveryStatus):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_contact_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageContactProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[ContactProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageContactProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageContactProjection.  # noqa: E501


        :return: The content of this PageContactProjection.  # noqa: E501
        :rtype: list[ContactProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageContactProjection.


        :param content: The content of this PageContactProjection.  # noqa: E501
        :type: list[ContactProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageContactProjection.  # noqa: E501


        :return: The pageable of this PageContactProjection.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageContactProjection.


        :param pageable: The pageable of this PageContactProjection.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageContactProjection.  # noqa: E501


        :return: The total_pages of this PageContactProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageContactProjection.


        :param total_pages: The total_pages of this PageContactProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageContactProjection.  # noqa: E501


        :return: The total_elements of this PageContactProjection.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageContactProjection.


        :param total_elements: The total_elements of this PageContactProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageContactProjection.  # noqa: E501


        :return: The last of this PageContactProjection.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageContactProjection.


        :param last: The last of this PageContactProjection.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageContactProjection.  # noqa: E501


        :return: The number_of_elements of this PageContactProjection.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageContactProjection.


        :param number_of_elements: The number_of_elements of this PageContactProjection.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageContactProjection.  # noqa: E501


        :return: The first of this PageContactProjection.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageContactProjection.


        :param first: The first of this PageContactProjection.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageContactProjection.  # noqa: E501


        :return: The size of this PageContactProjection.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageContactProjection.


        :param size: The size of this PageContactProjection.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageContactProjection.  # noqa: E501


        :return: The number of this PageContactProjection.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageContactProjection.


        :param number: The number of this PageContactProjection.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageContactProjection.  # noqa: E501


        :return: The sort of this PageContactProjection.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageContactProjection.


        :param sort: The sort of this PageContactProjection.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageContactProjection.  # noqa: E501


        :return: The empty of this PageContactProjection.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageContactProjection.


        :param empty: The empty of this PageContactProjection.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageContactProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageContactProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_connector_sync_events.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageConnectorSyncEvents(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[ConnectorSyncEventProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageConnectorSyncEvents - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageConnectorSyncEvents.  # noqa: E501


        :return: The content of this PageConnectorSyncEvents.  # noqa: E501
        :rtype: list[ConnectorSyncEventProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageConnectorSyncEvents.


        :param content: The content of this PageConnectorSyncEvents.  # noqa: E501
        :type: list[ConnectorSyncEventProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageConnectorSyncEvents.  # noqa: E501


        :return: The pageable of this PageConnectorSyncEvents.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageConnectorSyncEvents.


        :param pageable: The pageable of this PageConnectorSyncEvents.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageConnectorSyncEvents.  # noqa: E501


        :return: The total_pages of this PageConnectorSyncEvents.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageConnectorSyncEvents.


        :param total_pages: The total_pages of this PageConnectorSyncEvents.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageConnectorSyncEvents.  # noqa: E501


        :return: The total_elements of this PageConnectorSyncEvents.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageConnectorSyncEvents.


        :param total_elements: The total_elements of this PageConnectorSyncEvents.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageConnectorSyncEvents.  # noqa: E501


        :return: The last of this PageConnectorSyncEvents.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageConnectorSyncEvents.


        :param last: The last of this PageConnectorSyncEvents.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageConnectorSyncEvents.  # noqa: E501


        :return: The number_of_elements of this PageConnectorSyncEvents.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageConnectorSyncEvents.


        :param number_of_elements: The number_of_elements of this PageConnectorSyncEvents.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageConnectorSyncEvents.  # noqa: E501


        :return: The first of this PageConnectorSyncEvents.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageConnectorSyncEvents.


        :param first: The first of this PageConnectorSyncEvents.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageConnectorSyncEvents.  # noqa: E501


        :return: The size of this PageConnectorSyncEvents.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageConnectorSyncEvents.


        :param size: The size of this PageConnectorSyncEvents.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageConnectorSyncEvents.  # noqa: E501


        :return: The number of this PageConnectorSyncEvents.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageConnectorSyncEvents.


        :param number: The number of this PageConnectorSyncEvents.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageConnectorSyncEvents.  # noqa: E501


        :return: The sort of this PageConnectorSyncEvents.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageConnectorSyncEvents.


        :param sort: The sort of this PageConnectorSyncEvents.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageConnectorSyncEvents.  # noqa: E501


        :return: The empty of this PageConnectorSyncEvents.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageConnectorSyncEvents.


        :param empty: The empty of this PageConnectorSyncEvents.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageConnectorSyncEvents):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageConnectorSyncEvents):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_connector.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageConnector(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[ConnectorProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageConnector - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageConnector.  # noqa: E501


        :return: The content of this PageConnector.  # noqa: E501
        :rtype: list[ConnectorProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageConnector.


        :param content: The content of this PageConnector.  # noqa: E501
        :type: list[ConnectorProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageConnector.  # noqa: E501


        :return: The pageable of this PageConnector.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageConnector.


        :param pageable: The pageable of this PageConnector.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageConnector.  # noqa: E501


        :return: The total_pages of this PageConnector.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageConnector.


        :param total_pages: The total_pages of this PageConnector.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageConnector.  # noqa: E501


        :return: The total_elements of this PageConnector.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageConnector.


        :param total_elements: The total_elements of this PageConnector.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageConnector.  # noqa: E501


        :return: The last of this PageConnector.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageConnector.


        :param last: The last of this PageConnector.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageConnector.  # noqa: E501


        :return: The number_of_elements of this PageConnector.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageConnector.


        :param number_of_elements: The number_of_elements of this PageConnector.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageConnector.  # noqa: E501


        :return: The first of this PageConnector.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageConnector.


        :param first: The first of this PageConnector.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageConnector.  # noqa: E501


        :return: The size of this PageConnector.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageConnector.


        :param size: The size of this PageConnector.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageConnector.  # noqa: E501


        :return: The number of this PageConnector.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageConnector.


        :param number: The number of this PageConnector.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageConnector.  # noqa: E501


        :return: The sort of this PageConnector.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageConnector.


        :param sort: The sort of this PageConnector.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageConnector.  # noqa: E501


        :return: The empty of this PageConnector.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageConnector.


        :param empty: The empty of this PageConnector.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageConnector):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageConnector):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_complaint.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageComplaint(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[Complaint]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageComplaint - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageComplaint.  # noqa: E501


        :return: The content of this PageComplaint.  # noqa: E501
        :rtype: list[Complaint]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageComplaint.


        :param content: The content of this PageComplaint.  # noqa: E501
        :type: list[Complaint]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageComplaint.  # noqa: E501


        :return: The pageable of this PageComplaint.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageComplaint.


        :param pageable: The pageable of this PageComplaint.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageComplaint.  # noqa: E501


        :return: The total_pages of this PageComplaint.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageComplaint.


        :param total_pages: The total_pages of this PageComplaint.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageComplaint.  # noqa: E501


        :return: The total_elements of this PageComplaint.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageComplaint.


        :param total_elements: The total_elements of this PageComplaint.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageComplaint.  # noqa: E501


        :return: The last of this PageComplaint.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageComplaint.


        :param last: The last of this PageComplaint.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageComplaint.  # noqa: E501


        :return: The number_of_elements of this PageComplaint.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageComplaint.


        :param number_of_elements: The number_of_elements of this PageComplaint.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageComplaint.  # noqa: E501


        :return: The first of this PageComplaint.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageComplaint.


        :param first: The first of this PageComplaint.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageComplaint.  # noqa: E501


        :return: The size of this PageComplaint.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageComplaint.


        :param size: The size of this PageComplaint.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageComplaint.  # noqa: E501


        :return: The number of this PageComplaint.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageComplaint.


        :param number: The number of this PageComplaint.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageComplaint.  # noqa: E501


        :return: The sort of this PageComplaint.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageComplaint.


        :param sort: The sort of this PageComplaint.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageComplaint.  # noqa: E501


        :return: The empty of this PageComplaint.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageComplaint.


        :param empty: The empty of this PageComplaint.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageComplaint):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageComplaint):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_bounced_recipients.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageBouncedRecipients(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[BounceRecipientProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageBouncedRecipients - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageBouncedRecipients.  # noqa: E501


        :return: The content of this PageBouncedRecipients.  # noqa: E501
        :rtype: list[BounceRecipientProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageBouncedRecipients.


        :param content: The content of this PageBouncedRecipients.  # noqa: E501
        :type: list[BounceRecipientProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageBouncedRecipients.  # noqa: E501


        :return: The pageable of this PageBouncedRecipients.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageBouncedRecipients.


        :param pageable: The pageable of this PageBouncedRecipients.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageBouncedRecipients.  # noqa: E501


        :return: The total_pages of this PageBouncedRecipients.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageBouncedRecipients.


        :param total_pages: The total_pages of this PageBouncedRecipients.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageBouncedRecipients.  # noqa: E501


        :return: The total_elements of this PageBouncedRecipients.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageBouncedRecipients.


        :param total_elements: The total_elements of this PageBouncedRecipients.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageBouncedRecipients.  # noqa: E501


        :return: The last of this PageBouncedRecipients.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageBouncedRecipients.


        :param last: The last of this PageBouncedRecipients.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageBouncedRecipients.  # noqa: E501


        :return: The number_of_elements of this PageBouncedRecipients.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageBouncedRecipients.


        :param number_of_elements: The number_of_elements of this PageBouncedRecipients.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageBouncedRecipients.  # noqa: E501


        :return: The first of this PageBouncedRecipients.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageBouncedRecipients.


        :param first: The first of this PageBouncedRecipients.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageBouncedRecipients.  # noqa: E501


        :return: The size of this PageBouncedRecipients.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageBouncedRecipients.


        :param size: The size of this PageBouncedRecipients.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageBouncedRecipients.  # noqa: E501


        :return: The number of this PageBouncedRecipients.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageBouncedRecipients.


        :param number: The number of this PageBouncedRecipients.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageBouncedRecipients.  # noqa: E501


        :return: The sort of this PageBouncedRecipients.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageBouncedRecipients.


        :param sort: The sort of this PageBouncedRecipients.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageBouncedRecipients.  # noqa: E501


        :return: The empty of this PageBouncedRecipients.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageBouncedRecipients.


        :param empty: The empty of this PageBouncedRecipients.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageBouncedRecipients):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageBouncedRecipients):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_bounced_email.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageBouncedEmail(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[BounceProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageBouncedEmail - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageBouncedEmail.  # noqa: E501


        :return: The content of this PageBouncedEmail.  # noqa: E501
        :rtype: list[BounceProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageBouncedEmail.


        :param content: The content of this PageBouncedEmail.  # noqa: E501
        :type: list[BounceProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageBouncedEmail.  # noqa: E501


        :return: The pageable of this PageBouncedEmail.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageBouncedEmail.


        :param pageable: The pageable of this PageBouncedEmail.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageBouncedEmail.  # noqa: E501


        :return: The total_pages of this PageBouncedEmail.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageBouncedEmail.


        :param total_pages: The total_pages of this PageBouncedEmail.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageBouncedEmail.  # noqa: E501


        :return: The total_elements of this PageBouncedEmail.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageBouncedEmail.


        :param total_elements: The total_elements of this PageBouncedEmail.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageBouncedEmail.  # noqa: E501


        :return: The last of this PageBouncedEmail.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageBouncedEmail.


        :param last: The last of this PageBouncedEmail.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageBouncedEmail.  # noqa: E501


        :return: The number_of_elements of this PageBouncedEmail.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageBouncedEmail.


        :param number_of_elements: The number_of_elements of this PageBouncedEmail.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageBouncedEmail.  # noqa: E501


        :return: The first of this PageBouncedEmail.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageBouncedEmail.


        :param first: The first of this PageBouncedEmail.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageBouncedEmail.  # noqa: E501


        :return: The size of this PageBouncedEmail.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageBouncedEmail.


        :param size: The size of this PageBouncedEmail.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageBouncedEmail.  # noqa: E501


        :return: The number of this PageBouncedEmail.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageBouncedEmail.


        :param number: The number of this PageBouncedEmail.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageBouncedEmail.  # noqa: E501


        :return: The sort of this PageBouncedEmail.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageBouncedEmail.


        :param sort: The sort of this PageBouncedEmail.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageBouncedEmail.  # noqa: E501


        :return: The empty of this PageBouncedEmail.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageBouncedEmail.


        :param empty: The empty of this PageBouncedEmail.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageBouncedEmail):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageBouncedEmail):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_attachment_entity.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageAttachmentEntity(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[AttachmentProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageAttachmentEntity - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageAttachmentEntity.  # noqa: E501


        :return: The content of this PageAttachmentEntity.  # noqa: E501
        :rtype: list[AttachmentProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageAttachmentEntity.


        :param content: The content of this PageAttachmentEntity.  # noqa: E501
        :type: list[AttachmentProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageAttachmentEntity.  # noqa: E501


        :return: The pageable of this PageAttachmentEntity.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageAttachmentEntity.


        :param pageable: The pageable of this PageAttachmentEntity.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageAttachmentEntity.  # noqa: E501


        :return: The total_pages of this PageAttachmentEntity.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageAttachmentEntity.


        :param total_pages: The total_pages of this PageAttachmentEntity.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageAttachmentEntity.  # noqa: E501


        :return: The total_elements of this PageAttachmentEntity.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageAttachmentEntity.


        :param total_elements: The total_elements of this PageAttachmentEntity.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageAttachmentEntity.  # noqa: E501


        :return: The last of this PageAttachmentEntity.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageAttachmentEntity.


        :param last: The last of this PageAttachmentEntity.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageAttachmentEntity.  # noqa: E501


        :return: The number_of_elements of this PageAttachmentEntity.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageAttachmentEntity.


        :param number_of_elements: The number_of_elements of this PageAttachmentEntity.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageAttachmentEntity.  # noqa: E501


        :return: The first of this PageAttachmentEntity.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageAttachmentEntity.


        :param first: The first of this PageAttachmentEntity.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageAttachmentEntity.  # noqa: E501


        :return: The size of this PageAttachmentEntity.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageAttachmentEntity.


        :param size: The size of this PageAttachmentEntity.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageAttachmentEntity.  # noqa: E501


        :return: The number of this PageAttachmentEntity.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageAttachmentEntity.


        :param number: The number of this PageAttachmentEntity.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageAttachmentEntity.  # noqa: E501


        :return: The sort of this PageAttachmentEntity.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageAttachmentEntity.


        :param sort: The sort of this PageAttachmentEntity.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageAttachmentEntity.  # noqa: E501


        :return: The empty of this PageAttachmentEntity.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageAttachmentEntity.


        :param empty: The empty of this PageAttachmentEntity.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageAttachmentEntity):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageAttachmentEntity):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/page_alias.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class PageAlias(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'list[AliasProjection]',
        'pageable': 'PageableObject',
        'total_pages': 'int',
        'total_elements': 'int',
        'last': 'bool',
        'number_of_elements': 'int',
        'first': 'bool',
        'size': 'int',
        'number': 'int',
        'sort': 'SortObject',
        'empty': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'pageable': 'pageable',
        'total_pages': 'totalPages',
        'total_elements': 'totalElements',
        'last': 'last',
        'number_of_elements': 'numberOfElements',
        'first': 'first',
        'size': 'size',
        'number': 'number',
        'sort': 'sort',
        'empty': 'empty'
    }

    def __init__(self, content=None, pageable=None, total_pages=None, total_elements=None, last=None, number_of_elements=None, first=None, size=None, number=None, sort=None, empty=None, local_vars_configuration=None):  # noqa: E501
        """PageAlias - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._pageable = None
        self._total_pages = None
        self._total_elements = None
        self._last = None
        self._number_of_elements = None
        self._first = None
        self._size = None
        self._number = None
        self._sort = None
        self._empty = None
        self.discriminator = None

        if content is not None:
            self.content = content
        if pageable is not None:
            self.pageable = pageable
        self.total_pages = total_pages
        self.total_elements = total_elements
        if last is not None:
            self.last = last
        if number_of_elements is not None:
            self.number_of_elements = number_of_elements
        if first is not None:
            self.first = first
        if size is not None:
            self.size = size
        if number is not None:
            self.number = number
        if sort is not None:
            self.sort = sort
        if empty is not None:
            self.empty = empty

    @property
    def content(self):
        """Gets the content of this PageAlias.  # noqa: E501


        :return: The content of this PageAlias.  # noqa: E501
        :rtype: list[AliasProjection]
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this PageAlias.


        :param content: The content of this PageAlias.  # noqa: E501
        :type: list[AliasProjection]
        """

        self._content = content

    @property
    def pageable(self):
        """Gets the pageable of this PageAlias.  # noqa: E501


        :return: The pageable of this PageAlias.  # noqa: E501
        :rtype: PageableObject
        """
        return self._pageable

    @pageable.setter
    def pageable(self, pageable):
        """Sets the pageable of this PageAlias.


        :param pageable: The pageable of this PageAlias.  # noqa: E501
        :type: PageableObject
        """

        self._pageable = pageable

    @property
    def total_pages(self):
        """Gets the total_pages of this PageAlias.  # noqa: E501


        :return: The total_pages of this PageAlias.  # noqa: E501
        :rtype: int
        """
        return self._total_pages

    @total_pages.setter
    def total_pages(self, total_pages):
        """Sets the total_pages of this PageAlias.


        :param total_pages: The total_pages of this PageAlias.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_pages is None:  # noqa: E501
            raise ValueError("Invalid value for `total_pages`, must not be `None`")  # noqa: E501

        self._total_pages = total_pages

    @property
    def total_elements(self):
        """Gets the total_elements of this PageAlias.  # noqa: E501


        :return: The total_elements of this PageAlias.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this PageAlias.


        :param total_elements: The total_elements of this PageAlias.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    @property
    def last(self):
        """Gets the last of this PageAlias.  # noqa: E501


        :return: The last of this PageAlias.  # noqa: E501
        :rtype: bool
        """
        return self._last

    @last.setter
    def last(self, last):
        """Sets the last of this PageAlias.


        :param last: The last of this PageAlias.  # noqa: E501
        :type: bool
        """

        self._last = last

    @property
    def number_of_elements(self):
        """Gets the number_of_elements of this PageAlias.  # noqa: E501


        :return: The number_of_elements of this PageAlias.  # noqa: E501
        :rtype: int
        """
        return self._number_of_elements

    @number_of_elements.setter
    def number_of_elements(self, number_of_elements):
        """Sets the number_of_elements of this PageAlias.


        :param number_of_elements: The number_of_elements of this PageAlias.  # noqa: E501
        :type: int
        """

        self._number_of_elements = number_of_elements

    @property
    def first(self):
        """Gets the first of this PageAlias.  # noqa: E501


        :return: The first of this PageAlias.  # noqa: E501
        :rtype: bool
        """
        return self._first

    @first.setter
    def first(self, first):
        """Sets the first of this PageAlias.


        :param first: The first of this PageAlias.  # noqa: E501
        :type: bool
        """

        self._first = first

    @property
    def size(self):
        """Gets the size of this PageAlias.  # noqa: E501


        :return: The size of this PageAlias.  # noqa: E501
        :rtype: int
        """
        return self._size

    @size.setter
    def size(self, size):
        """Sets the size of this PageAlias.


        :param size: The size of this PageAlias.  # noqa: E501
        :type: int
        """

        self._size = size

    @property
    def number(self):
        """Gets the number of this PageAlias.  # noqa: E501


        :return: The number of this PageAlias.  # noqa: E501
        :rtype: int
        """
        return self._number

    @number.setter
    def number(self, number):
        """Sets the number of this PageAlias.


        :param number: The number of this PageAlias.  # noqa: E501
        :type: int
        """

        self._number = number

    @property
    def sort(self):
        """Gets the sort of this PageAlias.  # noqa: E501


        :return: The sort of this PageAlias.  # noqa: E501
        :rtype: SortObject
        """
        return self._sort

    @sort.setter
    def sort(self, sort):
        """Sets the sort of this PageAlias.


        :param sort: The sort of this PageAlias.  # noqa: E501
        :type: SortObject
        """

        self._sort = sort

    @property
    def empty(self):
        """Gets the empty of this PageAlias.  # noqa: E501


        :return: The empty of this PageAlias.  # noqa: E501
        :rtype: bool
        """
        return self._empty

    @empty.setter
    def empty(self, empty):
        """Sets the empty of this PageAlias.


        :param empty: The empty of this PageAlias.  # noqa: E501
        :type: bool
        """

        self._empty = empty

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, PageAlias):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, PageAlias):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/organization_inbox_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class OrganizationInboxProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'domain_id': 'str',
        'created_at': 'datetime',
        'name': 'str',
        'email_address': 'str',
        'favourite': 'bool',
        'tags': 'list[str]',
        'team_access': 'bool',
        'inbox_type': 'str',
        'read_only': 'bool',
        'virtual_inbox': 'bool',
        'functions_as': 'str'
    }

    attribute_map = {
        'id': 'id',
        'domain_id': 'domainId',
        'created_at': 'createdAt',
        'name': 'name',
        'email_address': 'emailAddress',
        'favourite': 'favourite',
        'tags': 'tags',
        'team_access': 'teamAccess',
        'inbox_type': 'inboxType',
        'read_only': 'readOnly',
        'virtual_inbox': 'virtualInbox',
        'functions_as': 'functionsAs'
    }

    def __init__(self, id=None, domain_id=None, created_at=None, name=None, email_address=None, favourite=None, tags=None, team_access=None, inbox_type=None, read_only=None, virtual_inbox=None, functions_as=None, local_vars_configuration=None):  # noqa: E501
        """OrganizationInboxProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._domain_id = None
        self._created_at = None
        self._name = None
        self._email_address = None
        self._favourite = None
        self._tags = None
        self._team_access = None
        self._inbox_type = None
        self._read_only = None
        self._virtual_inbox = None
        self._functions_as = None
        self.discriminator = None

        self.id = id
        self.domain_id = domain_id
        self.created_at = created_at
        self.name = name
        self.email_address = email_address
        self.favourite = favourite
        self.tags = tags
        self.team_access = team_access
        self.inbox_type = inbox_type
        self.read_only = read_only
        self.virtual_inbox = virtual_inbox
        self.functions_as = functions_as

    @property
    def id(self):
        """Gets the id of this OrganizationInboxProjection.  # noqa: E501

        ID of the inbox. The ID is a UUID-V4 format string. Use the inboxId for calls to Inbox and Email Controller endpoints. See the emailAddress property for the email address or the inbox. To get emails in an inbox use the WaitFor and Inbox Controller methods `waitForLatestEmail` and `getEmails` methods respectively. Inboxes can be used with aliases to forward emails automatically.  # noqa: E501

        :return: The id of this OrganizationInboxProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this OrganizationInboxProjection.

        ID of the inbox. The ID is a UUID-V4 format string. Use the inboxId for calls to Inbox and Email Controller endpoints. See the emailAddress property for the email address or the inbox. To get emails in an inbox use the WaitFor and Inbox Controller methods `waitForLatestEmail` and `getEmails` methods respectively. Inboxes can be used with aliases to forward emails automatically.  # noqa: E501

        :param id: The id of this OrganizationInboxProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def domain_id(self):
        """Gets the domain_id of this OrganizationInboxProjection.  # noqa: E501

        ID of custom domain used by the inbox if any  # noqa: E501

        :return: The domain_id of this OrganizationInboxProjection.  # noqa: E501
        :rtype: str
        """
        return self._domain_id

    @domain_id.setter
    def domain_id(self, domain_id):
        """Sets the domain_id of this OrganizationInboxProjection.

        ID of custom domain used by the inbox if any  # noqa: E501

        :param domain_id: The domain_id of this OrganizationInboxProjection.  # noqa: E501
        :type: str
        """

        self._domain_id = domain_id

    @property
    def created_at(self):
        """Gets the created_at of this OrganizationInboxProjection.  # noqa: E501

        When the inbox was created. Time stamps are in ISO DateTime Format `yyyy-MM-dd'T'HH:mm:ss.SSSXXX` e.g. `2000-10-31T01:30:00.000-05:00`.  # noqa: E501

        :return: The created_at of this OrganizationInboxProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this OrganizationInboxProjection.

        When the inbox was created. Time stamps are in ISO DateTime Format `yyyy-MM-dd'T'HH:mm:ss.SSSXXX` e.g. `2000-10-31T01:30:00.000-05:00`.  # noqa: E501

        :param created_at: The created_at of this OrganizationInboxProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def name(self):
        """Gets the name of this OrganizationInboxProjection.  # noqa: E501

        Name of the inbox and used as the sender name when sending emails .Displayed in the dashboard for easier search  # noqa: E501

        :return: The name of this OrganizationInboxProjection.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this OrganizationInboxProjection.

        Name of the inbox and used as the sender name when sending emails .Displayed in the dashboard for easier search  # noqa: E501

        :param name: The name of this OrganizationInboxProjection.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def email_address(self):
        """Gets the email_address of this OrganizationInboxProjection.  # noqa: E501

        The inbox's email address. Inbox projections and previews may not include the email address. To view the email address fetch the inbox entity directly. Send an email to this address and the inbox will receive and store it for you. Note the email address in MailSlurp match characters exactly and are case sensitive so `+123` additions are considered different addresses. To retrieve the email use the Inbox and Email Controller endpoints with the inbox ID.  # noqa: E501

        :return: The email_address of this OrganizationInboxProjection.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this OrganizationInboxProjection.

        The inbox's email address. Inbox projections and previews may not include the email address. To view the email address fetch the inbox entity directly. Send an email to this address and the inbox will receive and store it for you. Note the email address in MailSlurp match characters exactly and are case sensitive so `+123` additions are considered different addresses. To retrieve the email use the Inbox and Email Controller endpoints with the inbox ID.  # noqa: E501

        :param email_address: The email_address of this OrganizationInboxProjection.  # noqa: E501
        :type: str
        """

        self._email_address = email_address

    @property
    def favourite(self):
        """Gets the favourite of this OrganizationInboxProjection.  # noqa: E501

        Is the inbox a favorite inbox. Make an inbox a favorite is typically done in the dashboard for quick access or filtering  # noqa: E501

        :return: The favourite of this OrganizationInboxProjection.  # noqa: E501
        :rtype: bool
        """
        return self._favourite

    @favourite.setter
    def favourite(self, favourite):
        """Sets the favourite of this OrganizationInboxProjection.

        Is the inbox a favorite inbox. Make an inbox a favorite is typically done in the dashboard for quick access or filtering  # noqa: E501

        :param favourite: The favourite of this OrganizationInboxProjection.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and favourite is None:  # noqa: E501
            raise ValueError("Invalid value for `favourite`, must not be `None`")  # noqa: E501

        self._favourite = favourite

    @property
    def tags(self):
        """Gets the tags of this OrganizationInboxProjection.  # noqa: E501

        Tags that inbox has been tagged with. Tags can be added to inboxes to group different inboxes within an account. You can also search for inboxes by tag in the dashboard UI.  # noqa: E501

        :return: The tags of this OrganizationInboxProjection.  # noqa: E501
        :rtype: list[str]
        """
        return self._tags

    @tags.setter
    def tags(self, tags):
        """Sets the tags of this OrganizationInboxProjection.

        Tags that inbox has been tagged with. Tags can be added to inboxes to group different inboxes within an account. You can also search for inboxes by tag in the dashboard UI.  # noqa: E501

        :param tags: The tags of this OrganizationInboxProjection.  # noqa: E501
        :type: list[str]
        """

        self._tags = tags

    @property
    def team_access(self):
        """Gets the team_access of this OrganizationInboxProjection.  # noqa: E501

        Does inbox permit team access for organization team members. If so team users can use inbox and emails associated with it. See the team access guide at https://www.mailslurp.com/guides/team-email-account-sharing/  # noqa: E501

        :return: The team_access of this OrganizationInboxProjection.  # noqa: E501
        :rtype: bool
        """
        return self._team_access

    @team_access.setter
    def team_access(self, team_access):
        """Sets the team_access of this OrganizationInboxProjection.

        Does inbox permit team access for organization team members. If so team users can use inbox and emails associated with it. See the team access guide at https://www.mailslurp.com/guides/team-email-account-sharing/  # noqa: E501

        :param team_access: The team_access of this OrganizationInboxProjection.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and team_access is None:  # noqa: E501
            raise ValueError("Invalid value for `team_access`, must not be `None`")  # noqa: E501

        self._team_access = team_access

    @property
    def inbox_type(self):
        """Gets the inbox_type of this OrganizationInboxProjection.  # noqa: E501

        Type of inbox. HTTP inboxes are faster and better for most cases. SMTP inboxes are more suited for public facing inbound messages (but cannot send).  # noqa: E501

        :return: The inbox_type of this OrganizationInboxProjection.  # noqa: E501
        :rtype: str
        """
        return self._inbox_type

    @inbox_type.setter
    def inbox_type(self, inbox_type):
        """Sets the inbox_type of this OrganizationInboxProjection.

        Type of inbox. HTTP inboxes are faster and better for most cases. SMTP inboxes are more suited for public facing inbound messages (but cannot send).  # noqa: E501

        :param inbox_type: The inbox_type of this OrganizationInboxProjection.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"HTTP_INBOX", "SMTP_INBOX"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and inbox_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `inbox_type` ({0}), must be one of {1}"  # noqa: E501
                .format(inbox_type, allowed_values)
            )

        self._inbox_type = inbox_type

    @property
    def read_only(self):
        """Gets the read_only of this OrganizationInboxProjection.  # noqa: E501

        Is the inbox readOnly for the caller. Read only means can not be deleted or modified. This flag is present when using team accounts and shared inboxes.  # noqa: E501

        :return: The read_only of this OrganizationInboxProjection.  # noqa: E501
        :rtype: bool
        """
        return self._read_only

    @read_only.setter
    def read_only(self, read_only):
        """Sets the read_only of this OrganizationInboxProjection.

        Is the inbox readOnly for the caller. Read only means can not be deleted or modified. This flag is present when using team accounts and shared inboxes.  # noqa: E501

        :param read_only: The read_only of this OrganizationInboxProjection.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and read_only is None:  # noqa: E501
            raise ValueError("Invalid value for `read_only`, must not be `None`")  # noqa: E501

        self._read_only = read_only

    @property
    def virtual_inbox(self):
        """Gets the virtual_inbox of this OrganizationInboxProjection.  # noqa: E501

        Virtual inbox can receive email but will not send emails to real recipients. Will save sent email record but never send an actual email. Perfect for testing mail server actions.  # noqa: E501

        :return: The virtual_inbox of this OrganizationInboxProjection.  # noqa: E501
        :rtype: bool
        """
        return self._virtual_inbox

    @virtual_inbox.setter
    def virtual_inbox(self, virtual_inbox):
        """Sets the virtual_inbox of this OrganizationInboxProjection.

        Virtual inbox can receive email but will not send emails to real recipients. Will save sent email record but never send an actual email. Perfect for testing mail server actions.  # noqa: E501

        :param virtual_inbox: The virtual_inbox of this OrganizationInboxProjection.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and virtual_inbox is None:  # noqa: E501
            raise ValueError("Invalid value for `virtual_inbox`, must not be `None`")  # noqa: E501

        self._virtual_inbox = virtual_inbox

    @property
    def functions_as(self):
        """Gets the functions_as of this OrganizationInboxProjection.  # noqa: E501

        Inbox function if used as a primitive for another system.  # noqa: E501

        :return: The functions_as of this OrganizationInboxProjection.  # noqa: E501
        :rtype: str
        """
        return self._functions_as

    @functions_as.setter
    def functions_as(self, functions_as):
        """Sets the functions_as of this OrganizationInboxProjection.

        Inbox function if used as a primitive for another system.  # noqa: E501

        :param functions_as: The functions_as of this OrganizationInboxProjection.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"ALIAS", "THREAD", "CATCH_ALL", "CONNECTOR"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and functions_as not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `functions_as` ({0}), must be one of {1}"  # noqa: E501
                .format(functions_as, allowed_values)
            )

        self._functions_as = functions_as

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, OrganizationInboxProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, OrganizationInboxProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/new_fake_email_address_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class NewFakeEmailAddressResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'email_address': 'str'
    }

    attribute_map = {
        'email_address': 'emailAddress'
    }

    def __init__(self, email_address=None, local_vars_configuration=None):  # noqa: E501
        """NewFakeEmailAddressResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._email_address = None
        self.discriminator = None

        self.email_address = email_address

    @property
    def email_address(self):
        """Gets the email_address of this NewFakeEmailAddressResult.  # noqa: E501


        :return: The email_address of this NewFakeEmailAddressResult.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this NewFakeEmailAddressResult.


        :param email_address: The email_address of this NewFakeEmailAddressResult.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, NewFakeEmailAddressResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, NewFakeEmailAddressResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/name_server_record.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class NameServerRecord(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'raw': 'str',
        'record_type': 'str',
        'priority': 'str',
        'value': 'str'
    }

    attribute_map = {
        'raw': 'raw',
        'record_type': 'recordType',
        'priority': 'priority',
        'value': 'value'
    }

    def __init__(self, raw=None, record_type=None, priority=None, value=None, local_vars_configuration=None):  # noqa: E501
        """NameServerRecord - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._raw = None
        self._record_type = None
        self._priority = None
        self._value = None
        self.discriminator = None

        self.raw = raw
        self.record_type = record_type
        self.priority = priority
        self.value = value

    @property
    def raw(self):
        """Gets the raw of this NameServerRecord.  # noqa: E501


        :return: The raw of this NameServerRecord.  # noqa: E501
        :rtype: str
        """
        return self._raw

    @raw.setter
    def raw(self, raw):
        """Sets the raw of this NameServerRecord.


        :param raw: The raw of this NameServerRecord.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and raw is None:  # noqa: E501
            raise ValueError("Invalid value for `raw`, must not be `None`")  # noqa: E501

        self._raw = raw

    @property
    def record_type(self):
        """Gets the record_type of this NameServerRecord.  # noqa: E501


        :return: The record_type of this NameServerRecord.  # noqa: E501
        :rtype: str
        """
        return self._record_type

    @record_type.setter
    def record_type(self, record_type):
        """Sets the record_type of this NameServerRecord.


        :param record_type: The record_type of this NameServerRecord.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and record_type is None:  # noqa: E501
            raise ValueError("Invalid value for `record_type`, must not be `None`")  # noqa: E501

        self._record_type = record_type

    @property
    def priority(self):
        """Gets the priority of this NameServerRecord.  # noqa: E501


        :return: The priority of this NameServerRecord.  # noqa: E501
        :rtype: str
        """
        return self._priority

    @priority.setter
    def priority(self, priority):
        """Sets the priority of this NameServerRecord.


        :param priority: The priority of this NameServerRecord.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and priority is None:  # noqa: E501
            raise ValueError("Invalid value for `priority`, must not be `None`")  # noqa: E501

        self._priority = priority

    @property
    def value(self):
        """Gets the value of this NameServerRecord.  # noqa: E501


        :return: The value of this NameServerRecord.  # noqa: E501
        :rtype: str
        """
        return self._value

    @value.setter
    def value(self, value):
        """Sets the value of this NameServerRecord.


        :param value: The value of this NameServerRecord.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and value is None:  # noqa: E501
            raise ValueError("Invalid value for `value`, must not be `None`")  # noqa: E501

        self._value = value

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, NameServerRecord):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, NameServerRecord):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/missed_email_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class MissedEmailProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'user_id': 'str',
        'subject': 'str',
        'id': 'str',
        '_from': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'user_id': 'userId',
        'subject': 'subject',
        'id': 'id',
        '_from': 'from'
    }

    def __init__(self, created_at=None, user_id=None, subject=None, id=None, _from=None, local_vars_configuration=None):  # noqa: E501
        """MissedEmailProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._user_id = None
        self._subject = None
        self._id = None
        self.__from = None
        self.discriminator = None

        self.created_at = created_at
        self.user_id = user_id
        self.subject = subject
        self.id = id
        self._from = _from

    @property
    def created_at(self):
        """Gets the created_at of this MissedEmailProjection.  # noqa: E501


        :return: The created_at of this MissedEmailProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this MissedEmailProjection.


        :param created_at: The created_at of this MissedEmailProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def user_id(self):
        """Gets the user_id of this MissedEmailProjection.  # noqa: E501


        :return: The user_id of this MissedEmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this MissedEmailProjection.


        :param user_id: The user_id of this MissedEmailProjection.  # noqa: E501
        :type: str
        """

        self._user_id = user_id

    @property
    def subject(self):
        """Gets the subject of this MissedEmailProjection.  # noqa: E501


        :return: The subject of this MissedEmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this MissedEmailProjection.


        :param subject: The subject of this MissedEmailProjection.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def id(self):
        """Gets the id of this MissedEmailProjection.  # noqa: E501


        :return: The id of this MissedEmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this MissedEmailProjection.


        :param id: The id of this MissedEmailProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def _from(self):
        """Gets the _from of this MissedEmailProjection.  # noqa: E501


        :return: The _from of this MissedEmailProjection.  # noqa: E501
        :rtype: str
        """
        return self.__from

    @_from.setter
    def _from(self, _from):
        """Sets the _from of this MissedEmailProjection.


        :param _from: The _from of this MissedEmailProjection.  # noqa: E501
        :type: str
        """

        self.__from = _from

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, MissedEmailProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, MissedEmailProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/missed_email_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class MissedEmailDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'subject': 'str',
        'body_excerpt': 'str',
        'attachment_count': 'int',
        '_from': 'str',
        'raw_url': 'str',
        'raw_key': 'str',
        'raw_bucket': 'str',
        'can_restore': 'bool',
        'to': 'list[str]',
        'cc': 'list[str]',
        'bcc': 'list[str]',
        'inbox_ids': 'list[str]',
        'created_at': 'datetime',
        'updated_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'subject': 'subject',
        'body_excerpt': 'bodyExcerpt',
        'attachment_count': 'attachmentCount',
        '_from': 'from',
        'raw_url': 'rawUrl',
        'raw_key': 'rawKey',
        'raw_bucket': 'rawBucket',
        'can_restore': 'canRestore',
        'to': 'to',
        'cc': 'cc',
        'bcc': 'bcc',
        'inbox_ids': 'inboxIds',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt'
    }

    def __init__(self, id=None, user_id=None, subject=None, body_excerpt=None, attachment_count=None, _from=None, raw_url=None, raw_key=None, raw_bucket=None, can_restore=None, to=None, cc=None, bcc=None, inbox_ids=None, created_at=None, updated_at=None, local_vars_configuration=None):  # noqa: E501
        """MissedEmailDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._subject = None
        self._body_excerpt = None
        self._attachment_count = None
        self.__from = None
        self._raw_url = None
        self._raw_key = None
        self._raw_bucket = None
        self._can_restore = None
        self._to = None
        self._cc = None
        self._bcc = None
        self._inbox_ids = None
        self._created_at = None
        self._updated_at = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        self.subject = subject
        self.body_excerpt = body_excerpt
        self.attachment_count = attachment_count
        self._from = _from
        self.raw_url = raw_url
        self.raw_key = raw_key
        self.raw_bucket = raw_bucket
        self.can_restore = can_restore
        self.to = to
        self.cc = cc
        self.bcc = bcc
        self.inbox_ids = inbox_ids
        self.created_at = created_at
        self.updated_at = updated_at

    @property
    def id(self):
        """Gets the id of this MissedEmailDto.  # noqa: E501


        :return: The id of this MissedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this MissedEmailDto.


        :param id: The id of this MissedEmailDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this MissedEmailDto.  # noqa: E501


        :return: The user_id of this MissedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this MissedEmailDto.


        :param user_id: The user_id of this MissedEmailDto.  # noqa: E501
        :type: str
        """

        self._user_id = user_id

    @property
    def subject(self):
        """Gets the subject of this MissedEmailDto.  # noqa: E501


        :return: The subject of this MissedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this MissedEmailDto.


        :param subject: The subject of this MissedEmailDto.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def body_excerpt(self):
        """Gets the body_excerpt of this MissedEmailDto.  # noqa: E501


        :return: The body_excerpt of this MissedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._body_excerpt

    @body_excerpt.setter
    def body_excerpt(self, body_excerpt):
        """Sets the body_excerpt of this MissedEmailDto.


        :param body_excerpt: The body_excerpt of this MissedEmailDto.  # noqa: E501
        :type: str
        """

        self._body_excerpt = body_excerpt

    @property
    def attachment_count(self):
        """Gets the attachment_count of this MissedEmailDto.  # noqa: E501


        :return: The attachment_count of this MissedEmailDto.  # noqa: E501
        :rtype: int
        """
        return self._attachment_count

    @attachment_count.setter
    def attachment_count(self, attachment_count):
        """Sets the attachment_count of this MissedEmailDto.


        :param attachment_count: The attachment_count of this MissedEmailDto.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and attachment_count is None:  # noqa: E501
            raise ValueError("Invalid value for `attachment_count`, must not be `None`")  # noqa: E501

        self._attachment_count = attachment_count

    @property
    def _from(self):
        """Gets the _from of this MissedEmailDto.  # noqa: E501


        :return: The _from of this MissedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self.__from

    @_from.setter
    def _from(self, _from):
        """Sets the _from of this MissedEmailDto.


        :param _from: The _from of this MissedEmailDto.  # noqa: E501
        :type: str
        """

        self.__from = _from

    @property
    def raw_url(self):
        """Gets the raw_url of this MissedEmailDto.  # noqa: E501


        :return: The raw_url of this MissedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._raw_url

    @raw_url.setter
    def raw_url(self, raw_url):
        """Sets the raw_url of this MissedEmailDto.


        :param raw_url: The raw_url of this MissedEmailDto.  # noqa: E501
        :type: str
        """

        self._raw_url = raw_url

    @property
    def raw_key(self):
        """Gets the raw_key of this MissedEmailDto.  # noqa: E501


        :return: The raw_key of this MissedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._raw_key

    @raw_key.setter
    def raw_key(self, raw_key):
        """Sets the raw_key of this MissedEmailDto.


        :param raw_key: The raw_key of this MissedEmailDto.  # noqa: E501
        :type: str
        """

        self._raw_key = raw_key

    @property
    def raw_bucket(self):
        """Gets the raw_bucket of this MissedEmailDto.  # noqa: E501


        :return: The raw_bucket of this MissedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._raw_bucket

    @raw_bucket.setter
    def raw_bucket(self, raw_bucket):
        """Sets the raw_bucket of this MissedEmailDto.


        :param raw_bucket: The raw_bucket of this MissedEmailDto.  # noqa: E501
        :type: str
        """

        self._raw_bucket = raw_bucket

    @property
    def can_restore(self):
        """Gets the can_restore of this MissedEmailDto.  # noqa: E501


        :return: The can_restore of this MissedEmailDto.  # noqa: E501
        :rtype: bool
        """
        return self._can_restore

    @can_restore.setter
    def can_restore(self, can_restore):
        """Sets the can_restore of this MissedEmailDto.


        :param can_restore: The can_restore of this MissedEmailDto.  # noqa: E501
        :type: bool
        """

        self._can_restore = can_restore

    @property
    def to(self):
        """Gets the to of this MissedEmailDto.  # noqa: E501


        :return: The to of this MissedEmailDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._to

    @to.setter
    def to(self, to):
        """Sets the to of this MissedEmailDto.


        :param to: The to of this MissedEmailDto.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and to is None:  # noqa: E501
            raise ValueError("Invalid value for `to`, must not be `None`")  # noqa: E501

        self._to = to

    @property
    def cc(self):
        """Gets the cc of this MissedEmailDto.  # noqa: E501


        :return: The cc of this MissedEmailDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._cc

    @cc.setter
    def cc(self, cc):
        """Sets the cc of this MissedEmailDto.


        :param cc: The cc of this MissedEmailDto.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and cc is None:  # noqa: E501
            raise ValueError("Invalid value for `cc`, must not be `None`")  # noqa: E501

        self._cc = cc

    @property
    def bcc(self):
        """Gets the bcc of this MissedEmailDto.  # noqa: E501


        :return: The bcc of this MissedEmailDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._bcc

    @bcc.setter
    def bcc(self, bcc):
        """Sets the bcc of this MissedEmailDto.


        :param bcc: The bcc of this MissedEmailDto.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and bcc is None:  # noqa: E501
            raise ValueError("Invalid value for `bcc`, must not be `None`")  # noqa: E501

        self._bcc = bcc

    @property
    def inbox_ids(self):
        """Gets the inbox_ids of this MissedEmailDto.  # noqa: E501


        :return: The inbox_ids of this MissedEmailDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._inbox_ids

    @inbox_ids.setter
    def inbox_ids(self, inbox_ids):
        """Sets the inbox_ids of this MissedEmailDto.


        :param inbox_ids: The inbox_ids of this MissedEmailDto.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and inbox_ids is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_ids`, must not be `None`")  # noqa: E501

        self._inbox_ids = inbox_ids

    @property
    def created_at(self):
        """Gets the created_at of this MissedEmailDto.  # noqa: E501


        :return: The created_at of this MissedEmailDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this MissedEmailDto.


        :param created_at: The created_at of this MissedEmailDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this MissedEmailDto.  # noqa: E501


        :return: The updated_at of this MissedEmailDto.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this MissedEmailDto.


        :param updated_at: The updated_at of this MissedEmailDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, MissedEmailDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, MissedEmailDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/match_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class MatchOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'matches': 'list[MatchOption]',
        'conditions': 'list[ConditionOption]'
    }

    attribute_map = {
        'matches': 'matches',
        'conditions': 'conditions'
    }

    def __init__(self, matches=None, conditions=None, local_vars_configuration=None):  # noqa: E501
        """MatchOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._matches = None
        self._conditions = None
        self.discriminator = None

        self.matches = matches
        self.conditions = conditions

    @property
    def matches(self):
        """Gets the matches of this MatchOptions.  # noqa: E501

        Zero or more match options such as `{ field: 'SUBJECT', should: 'CONTAIN', value: 'Welcome' }`. Options are additive so if one does not match the email is excluded from results  # noqa: E501

        :return: The matches of this MatchOptions.  # noqa: E501
        :rtype: list[MatchOption]
        """
        return self._matches

    @matches.setter
    def matches(self, matches):
        """Sets the matches of this MatchOptions.

        Zero or more match options such as `{ field: 'SUBJECT', should: 'CONTAIN', value: 'Welcome' }`. Options are additive so if one does not match the email is excluded from results  # noqa: E501

        :param matches: The matches of this MatchOptions.  # noqa: E501
        :type: list[MatchOption]
        """

        self._matches = matches

    @property
    def conditions(self):
        """Gets the conditions of this MatchOptions.  # noqa: E501

        Zero or more conditions such as `{ condition: 'HAS_ATTACHMENTS', value: 'TRUE' }`. Note the values are the strings `TRUE|FALSE` not booleans.  # noqa: E501

        :return: The conditions of this MatchOptions.  # noqa: E501
        :rtype: list[ConditionOption]
        """
        return self._conditions

    @conditions.setter
    def conditions(self, conditions):
        """Sets the conditions of this MatchOptions.

        Zero or more conditions such as `{ condition: 'HAS_ATTACHMENTS', value: 'TRUE' }`. Note the values are the strings `TRUE|FALSE` not booleans.  # noqa: E501

        :param conditions: The conditions of this MatchOptions.  # noqa: E501
        :type: list[ConditionOption]
        """

        self._conditions = conditions

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, MatchOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, MatchOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/match_option.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class MatchOption(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'field': 'str',
        'should': 'str',
        'value': 'str'
    }

    attribute_map = {
        'field': 'field',
        'should': 'should',
        'value': 'value'
    }

    def __init__(self, field=None, should=None, value=None, local_vars_configuration=None):  # noqa: E501
        """MatchOption - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._field = None
        self._should = None
        self._value = None
        self.discriminator = None

        self.field = field
        self.should = should
        self.value = value

    @property
    def field(self):
        """Gets the field of this MatchOption.  # noqa: E501

        Fields of an email object that can be used to filter results  # noqa: E501

        :return: The field of this MatchOption.  # noqa: E501
        :rtype: str
        """
        return self._field

    @field.setter
    def field(self, field):
        """Sets the field of this MatchOption.

        Fields of an email object that can be used to filter results  # noqa: E501

        :param field: The field of this MatchOption.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and field is None:  # noqa: E501
            raise ValueError("Invalid value for `field`, must not be `None`")  # noqa: E501
        allowed_values = ["SUBJECT", "TO", "BCC", "CC", "FROM", "HEADERS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and field not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `field` ({0}), must be one of {1}"  # noqa: E501
                .format(field, allowed_values)
            )

        self._field = field

    @property
    def should(self):
        """Gets the should of this MatchOption.  # noqa: E501

        How the value of the email field specified should be compared to the value given in the match options.  # noqa: E501

        :return: The should of this MatchOption.  # noqa: E501
        :rtype: str
        """
        return self._should

    @should.setter
    def should(self, should):
        """Sets the should of this MatchOption.

        How the value of the email field specified should be compared to the value given in the match options.  # noqa: E501

        :param should: The should of this MatchOption.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and should is None:  # noqa: E501
            raise ValueError("Invalid value for `should`, must not be `None`")  # noqa: E501
        allowed_values = ["MATCH", "CONTAIN", "EQUAL"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and should not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `should` ({0}), must be one of {1}"  # noqa: E501
                .format(should, allowed_values)
            )

        self._should = should

    @property
    def value(self):
        """Gets the value of this MatchOption.  # noqa: E501

        The value you wish to compare with the value of the field specified using the `should` value passed. For example `BODY` should `CONTAIN` a value passed.  # noqa: E501

        :return: The value of this MatchOption.  # noqa: E501
        :rtype: str
        """
        return self._value

    @value.setter
    def value(self, value):
        """Sets the value of this MatchOption.

        The value you wish to compare with the value of the field specified using the `should` value passed. For example `BODY` should `CONTAIN` a value passed.  # noqa: E501

        :param value: The value of this MatchOption.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and value is None:  # noqa: E501
            raise ValueError("Invalid value for `value`, must not be `None`")  # noqa: E501

        self._value = value

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, MatchOption):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, MatchOption):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/lookup_tls_reporting_domain_results.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class LookupTlsReportingDomainResults(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'valid': 'bool',
        'query': 'DNSLookupOptions',
        'records': 'list[DNSLookupResult]',
        'errors': 'list[str]',
        'warnings': 'list[str]'
    }

    attribute_map = {
        'valid': 'valid',
        'query': 'query',
        'records': 'records',
        'errors': 'errors',
        'warnings': 'warnings'
    }

    def __init__(self, valid=None, query=None, records=None, errors=None, warnings=None, local_vars_configuration=None):  # noqa: E501
        """LookupTlsReportingDomainResults - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._valid = None
        self._query = None
        self._records = None
        self._errors = None
        self._warnings = None
        self.discriminator = None

        self.valid = valid
        self.query = query
        self.records = records
        self.errors = errors
        self.warnings = warnings

    @property
    def valid(self):
        """Gets the valid of this LookupTlsReportingDomainResults.  # noqa: E501


        :return: The valid of this LookupTlsReportingDomainResults.  # noqa: E501
        :rtype: bool
        """
        return self._valid

    @valid.setter
    def valid(self, valid):
        """Sets the valid of this LookupTlsReportingDomainResults.


        :param valid: The valid of this LookupTlsReportingDomainResults.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and valid is None:  # noqa: E501
            raise ValueError("Invalid value for `valid`, must not be `None`")  # noqa: E501

        self._valid = valid

    @property
    def query(self):
        """Gets the query of this LookupTlsReportingDomainResults.  # noqa: E501


        :return: The query of this LookupTlsReportingDomainResults.  # noqa: E501
        :rtype: DNSLookupOptions
        """
        return self._query

    @query.setter
    def query(self, query):
        """Sets the query of this LookupTlsReportingDomainResults.


        :param query: The query of this LookupTlsReportingDomainResults.  # noqa: E501
        :type: DNSLookupOptions
        """
        if self.local_vars_configuration.client_side_validation and query is None:  # noqa: E501
            raise ValueError("Invalid value for `query`, must not be `None`")  # noqa: E501

        self._query = query

    @property
    def records(self):
        """Gets the records of this LookupTlsReportingDomainResults.  # noqa: E501


        :return: The records of this LookupTlsReportingDomainResults.  # noqa: E501
        :rtype: list[DNSLookupResult]
        """
        return self._records

    @records.setter
    def records(self, records):
        """Sets the records of this LookupTlsReportingDomainResults.


        :param records: The records of this LookupTlsReportingDomainResults.  # noqa: E501
        :type: list[DNSLookupResult]
        """
        if self.local_vars_configuration.client_side_validation and records is None:  # noqa: E501
            raise ValueError("Invalid value for `records`, must not be `None`")  # noqa: E501

        self._records = records

    @property
    def errors(self):
        """Gets the errors of this LookupTlsReportingDomainResults.  # noqa: E501


        :return: The errors of this LookupTlsReportingDomainResults.  # noqa: E501
        :rtype: list[str]
        """
        return self._errors

    @errors.setter
    def errors(self, errors):
        """Sets the errors of this LookupTlsReportingDomainResults.


        :param errors: The errors of this LookupTlsReportingDomainResults.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and errors is None:  # noqa: E501
            raise ValueError("Invalid value for `errors`, must not be `None`")  # noqa: E501

        self._errors = errors

    @property
    def warnings(self):
        """Gets the warnings of this LookupTlsReportingDomainResults.  # noqa: E501


        :return: The warnings of this LookupTlsReportingDomainResults.  # noqa: E501
        :rtype: list[str]
        """
        return self._warnings

    @warnings.setter
    def warnings(self, warnings):
        """Sets the warnings of this LookupTlsReportingDomainResults.


        :param warnings: The warnings of this LookupTlsReportingDomainResults.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and warnings is None:  # noqa: E501
            raise ValueError("Invalid value for `warnings`, must not be `None`")  # noqa: E501

        self._warnings = warnings

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, LookupTlsReportingDomainResults):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, LookupTlsReportingDomainResults):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/lookup_tls_reporting_domain_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class LookupTlsReportingDomainOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'host': 'str'
    }

    attribute_map = {
        'host': 'host'
    }

    def __init__(self, host=None, local_vars_configuration=None):  # noqa: E501
        """LookupTlsReportingDomainOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._host = None
        self.discriminator = None

        self.host = host

    @property
    def host(self):
        """Gets the host of this LookupTlsReportingDomainOptions.  # noqa: E501


        :return: The host of this LookupTlsReportingDomainOptions.  # noqa: E501
        :rtype: str
        """
        return self._host

    @host.setter
    def host(self, host):
        """Sets the host of this LookupTlsReportingDomainOptions.


        :param host: The host of this LookupTlsReportingDomainOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and host is None:  # noqa: E501
            raise ValueError("Invalid value for `host`, must not be `None`")  # noqa: E501

        self._host = host

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, LookupTlsReportingDomainOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, LookupTlsReportingDomainOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/lookup_mta_sts_domain_results.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class LookupMtaStsDomainResults(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'valid': 'bool',
        'query': 'DNSLookupOptions',
        'records': 'list[DNSLookupResult]',
        'well_known_query': 'str',
        'well_known_present': 'bool',
        'well_known_value': 'str',
        'errors': 'list[str]',
        'warnings': 'list[str]'
    }

    attribute_map = {
        'valid': 'valid',
        'query': 'query',
        'records': 'records',
        'well_known_query': 'wellKnownQuery',
        'well_known_present': 'wellKnownPresent',
        'well_known_value': 'wellKnownValue',
        'errors': 'errors',
        'warnings': 'warnings'
    }

    def __init__(self, valid=None, query=None, records=None, well_known_query=None, well_known_present=None, well_known_value=None, errors=None, warnings=None, local_vars_configuration=None):  # noqa: E501
        """LookupMtaStsDomainResults - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._valid = None
        self._query = None
        self._records = None
        self._well_known_query = None
        self._well_known_present = None
        self._well_known_value = None
        self._errors = None
        self._warnings = None
        self.discriminator = None

        self.valid = valid
        self.query = query
        self.records = records
        self.well_known_query = well_known_query
        self.well_known_present = well_known_present
        self.well_known_value = well_known_value
        self.errors = errors
        self.warnings = warnings

    @property
    def valid(self):
        """Gets the valid of this LookupMtaStsDomainResults.  # noqa: E501


        :return: The valid of this LookupMtaStsDomainResults.  # noqa: E501
        :rtype: bool
        """
        return self._valid

    @valid.setter
    def valid(self, valid):
        """Sets the valid of this LookupMtaStsDomainResults.


        :param valid: The valid of this LookupMtaStsDomainResults.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and valid is None:  # noqa: E501
            raise ValueError("Invalid value for `valid`, must not be `None`")  # noqa: E501

        self._valid = valid

    @property
    def query(self):
        """Gets the query of this LookupMtaStsDomainResults.  # noqa: E501


        :return: The query of this LookupMtaStsDomainResults.  # noqa: E501
        :rtype: DNSLookupOptions
        """
        return self._query

    @query.setter
    def query(self, query):
        """Sets the query of this LookupMtaStsDomainResults.


        :param query: The query of this LookupMtaStsDomainResults.  # noqa: E501
        :type: DNSLookupOptions
        """
        if self.local_vars_configuration.client_side_validation and query is None:  # noqa: E501
            raise ValueError("Invalid value for `query`, must not be `None`")  # noqa: E501

        self._query = query

    @property
    def records(self):
        """Gets the records of this LookupMtaStsDomainResults.  # noqa: E501


        :return: The records of this LookupMtaStsDomainResults.  # noqa: E501
        :rtype: list[DNSLookupResult]
        """
        return self._records

    @records.setter
    def records(self, records):
        """Sets the records of this LookupMtaStsDomainResults.


        :param records: The records of this LookupMtaStsDomainResults.  # noqa: E501
        :type: list[DNSLookupResult]
        """
        if self.local_vars_configuration.client_side_validation and records is None:  # noqa: E501
            raise ValueError("Invalid value for `records`, must not be `None`")  # noqa: E501

        self._records = records

    @property
    def well_known_query(self):
        """Gets the well_known_query of this LookupMtaStsDomainResults.  # noqa: E501


        :return: The well_known_query of this LookupMtaStsDomainResults.  # noqa: E501
        :rtype: str
        """
        return self._well_known_query

    @well_known_query.setter
    def well_known_query(self, well_known_query):
        """Sets the well_known_query of this LookupMtaStsDomainResults.


        :param well_known_query: The well_known_query of this LookupMtaStsDomainResults.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and well_known_query is None:  # noqa: E501
            raise ValueError("Invalid value for `well_known_query`, must not be `None`")  # noqa: E501

        self._well_known_query = well_known_query

    @property
    def well_known_present(self):
        """Gets the well_known_present of this LookupMtaStsDomainResults.  # noqa: E501


        :return: The well_known_present of this LookupMtaStsDomainResults.  # noqa: E501
        :rtype: bool
        """
        return self._well_known_present

    @well_known_present.setter
    def well_known_present(self, well_known_present):
        """Sets the well_known_present of this LookupMtaStsDomainResults.


        :param well_known_present: The well_known_present of this LookupMtaStsDomainResults.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and well_known_present is None:  # noqa: E501
            raise ValueError("Invalid value for `well_known_present`, must not be `None`")  # noqa: E501

        self._well_known_present = well_known_present

    @property
    def well_known_value(self):
        """Gets the well_known_value of this LookupMtaStsDomainResults.  # noqa: E501


        :return: The well_known_value of this LookupMtaStsDomainResults.  # noqa: E501
        :rtype: str
        """
        return self._well_known_value

    @well_known_value.setter
    def well_known_value(self, well_known_value):
        """Sets the well_known_value of this LookupMtaStsDomainResults.


        :param well_known_value: The well_known_value of this LookupMtaStsDomainResults.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and well_known_value is None:  # noqa: E501
            raise ValueError("Invalid value for `well_known_value`, must not be `None`")  # noqa: E501

        self._well_known_value = well_known_value

    @property
    def errors(self):
        """Gets the errors of this LookupMtaStsDomainResults.  # noqa: E501


        :return: The errors of this LookupMtaStsDomainResults.  # noqa: E501
        :rtype: list[str]
        """
        return self._errors

    @errors.setter
    def errors(self, errors):
        """Sets the errors of this LookupMtaStsDomainResults.


        :param errors: The errors of this LookupMtaStsDomainResults.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and errors is None:  # noqa: E501
            raise ValueError("Invalid value for `errors`, must not be `None`")  # noqa: E501

        self._errors = errors

    @property
    def warnings(self):
        """Gets the warnings of this LookupMtaStsDomainResults.  # noqa: E501


        :return: The warnings of this LookupMtaStsDomainResults.  # noqa: E501
        :rtype: list[str]
        """
        return self._warnings

    @warnings.setter
    def warnings(self, warnings):
        """Sets the warnings of this LookupMtaStsDomainResults.


        :param warnings: The warnings of this LookupMtaStsDomainResults.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and warnings is None:  # noqa: E501
            raise ValueError("Invalid value for `warnings`, must not be `None`")  # noqa: E501

        self._warnings = warnings

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, LookupMtaStsDomainResults):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, LookupMtaStsDomainResults):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/lookup_mta_sts_domain_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class LookupMtaStsDomainOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'host': 'str'
    }

    attribute_map = {
        'host': 'host'
    }

    def __init__(self, host=None, local_vars_configuration=None):  # noqa: E501
        """LookupMtaStsDomainOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._host = None
        self.discriminator = None

        self.host = host

    @property
    def host(self):
        """Gets the host of this LookupMtaStsDomainOptions.  # noqa: E501


        :return: The host of this LookupMtaStsDomainOptions.  # noqa: E501
        :rtype: str
        """
        return self._host

    @host.setter
    def host(self, host):
        """Sets the host of this LookupMtaStsDomainOptions.


        :param host: The host of this LookupMtaStsDomainOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and host is None:  # noqa: E501
            raise ValueError("Invalid value for `host`, must not be `None`")  # noqa: E501

        self._host = host

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, LookupMtaStsDomainOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, LookupMtaStsDomainOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/lookup_dmarc_domain_results.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class LookupDmarcDomainResults(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'valid': 'bool',
        'query': 'DNSLookupOptions',
        'records': 'list[DNSLookupResult]',
        'errors': 'list[str]',
        'warnings': 'list[str]'
    }

    attribute_map = {
        'valid': 'valid',
        'query': 'query',
        'records': 'records',
        'errors': 'errors',
        'warnings': 'warnings'
    }

    def __init__(self, valid=None, query=None, records=None, errors=None, warnings=None, local_vars_configuration=None):  # noqa: E501
        """LookupDmarcDomainResults - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._valid = None
        self._query = None
        self._records = None
        self._errors = None
        self._warnings = None
        self.discriminator = None

        self.valid = valid
        self.query = query
        self.records = records
        self.errors = errors
        self.warnings = warnings

    @property
    def valid(self):
        """Gets the valid of this LookupDmarcDomainResults.  # noqa: E501


        :return: The valid of this LookupDmarcDomainResults.  # noqa: E501
        :rtype: bool
        """
        return self._valid

    @valid.setter
    def valid(self, valid):
        """Sets the valid of this LookupDmarcDomainResults.


        :param valid: The valid of this LookupDmarcDomainResults.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and valid is None:  # noqa: E501
            raise ValueError("Invalid value for `valid`, must not be `None`")  # noqa: E501

        self._valid = valid

    @property
    def query(self):
        """Gets the query of this LookupDmarcDomainResults.  # noqa: E501


        :return: The query of this LookupDmarcDomainResults.  # noqa: E501
        :rtype: DNSLookupOptions
        """
        return self._query

    @query.setter
    def query(self, query):
        """Sets the query of this LookupDmarcDomainResults.


        :param query: The query of this LookupDmarcDomainResults.  # noqa: E501
        :type: DNSLookupOptions
        """
        if self.local_vars_configuration.client_side_validation and query is None:  # noqa: E501
            raise ValueError("Invalid value for `query`, must not be `None`")  # noqa: E501

        self._query = query

    @property
    def records(self):
        """Gets the records of this LookupDmarcDomainResults.  # noqa: E501


        :return: The records of this LookupDmarcDomainResults.  # noqa: E501
        :rtype: list[DNSLookupResult]
        """
        return self._records

    @records.setter
    def records(self, records):
        """Sets the records of this LookupDmarcDomainResults.


        :param records: The records of this LookupDmarcDomainResults.  # noqa: E501
        :type: list[DNSLookupResult]
        """
        if self.local_vars_configuration.client_side_validation and records is None:  # noqa: E501
            raise ValueError("Invalid value for `records`, must not be `None`")  # noqa: E501

        self._records = records

    @property
    def errors(self):
        """Gets the errors of this LookupDmarcDomainResults.  # noqa: E501


        :return: The errors of this LookupDmarcDomainResults.  # noqa: E501
        :rtype: list[str]
        """
        return self._errors

    @errors.setter
    def errors(self, errors):
        """Sets the errors of this LookupDmarcDomainResults.


        :param errors: The errors of this LookupDmarcDomainResults.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and errors is None:  # noqa: E501
            raise ValueError("Invalid value for `errors`, must not be `None`")  # noqa: E501

        self._errors = errors

    @property
    def warnings(self):
        """Gets the warnings of this LookupDmarcDomainResults.  # noqa: E501


        :return: The warnings of this LookupDmarcDomainResults.  # noqa: E501
        :rtype: list[str]
        """
        return self._warnings

    @warnings.setter
    def warnings(self, warnings):
        """Sets the warnings of this LookupDmarcDomainResults.


        :param warnings: The warnings of this LookupDmarcDomainResults.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and warnings is None:  # noqa: E501
            raise ValueError("Invalid value for `warnings`, must not be `None`")  # noqa: E501

        self._warnings = warnings

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, LookupDmarcDomainResults):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, LookupDmarcDomainResults):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/lookup_dmarc_domain_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class LookupDmarcDomainOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'host': 'str'
    }

    attribute_map = {
        'host': 'host'
    }

    def __init__(self, host=None, local_vars_configuration=None):  # noqa: E501
        """LookupDmarcDomainOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._host = None
        self.discriminator = None

        self.host = host

    @property
    def host(self):
        """Gets the host of this LookupDmarcDomainOptions.  # noqa: E501


        :return: The host of this LookupDmarcDomainOptions.  # noqa: E501
        :rtype: str
        """
        return self._host

    @host.setter
    def host(self, host):
        """Sets the host of this LookupDmarcDomainOptions.


        :param host: The host of this LookupDmarcDomainOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and host is None:  # noqa: E501
            raise ValueError("Invalid value for `host`, must not be `None`")  # noqa: E501

        self._host = host

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, LookupDmarcDomainOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, LookupDmarcDomainOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/lookup_bimi_domain_results.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class LookupBimiDomainResults(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'valid': 'bool',
        'query': 'DNSLookupOptions',
        'records': 'list[DNSLookupResult]',
        'errors': 'list[str]',
        'warnings': 'list[str]'
    }

    attribute_map = {
        'valid': 'valid',
        'query': 'query',
        'records': 'records',
        'errors': 'errors',
        'warnings': 'warnings'
    }

    def __init__(self, valid=None, query=None, records=None, errors=None, warnings=None, local_vars_configuration=None):  # noqa: E501
        """LookupBimiDomainResults - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._valid = None
        self._query = None
        self._records = None
        self._errors = None
        self._warnings = None
        self.discriminator = None

        self.valid = valid
        self.query = query
        self.records = records
        self.errors = errors
        self.warnings = warnings

    @property
    def valid(self):
        """Gets the valid of this LookupBimiDomainResults.  # noqa: E501


        :return: The valid of this LookupBimiDomainResults.  # noqa: E501
        :rtype: bool
        """
        return self._valid

    @valid.setter
    def valid(self, valid):
        """Sets the valid of this LookupBimiDomainResults.


        :param valid: The valid of this LookupBimiDomainResults.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and valid is None:  # noqa: E501
            raise ValueError("Invalid value for `valid`, must not be `None`")  # noqa: E501

        self._valid = valid

    @property
    def query(self):
        """Gets the query of this LookupBimiDomainResults.  # noqa: E501


        :return: The query of this LookupBimiDomainResults.  # noqa: E501
        :rtype: DNSLookupOptions
        """
        return self._query

    @query.setter
    def query(self, query):
        """Sets the query of this LookupBimiDomainResults.


        :param query: The query of this LookupBimiDomainResults.  # noqa: E501
        :type: DNSLookupOptions
        """
        if self.local_vars_configuration.client_side_validation and query is None:  # noqa: E501
            raise ValueError("Invalid value for `query`, must not be `None`")  # noqa: E501

        self._query = query

    @property
    def records(self):
        """Gets the records of this LookupBimiDomainResults.  # noqa: E501


        :return: The records of this LookupBimiDomainResults.  # noqa: E501
        :rtype: list[DNSLookupResult]
        """
        return self._records

    @records.setter
    def records(self, records):
        """Sets the records of this LookupBimiDomainResults.


        :param records: The records of this LookupBimiDomainResults.  # noqa: E501
        :type: list[DNSLookupResult]
        """
        if self.local_vars_configuration.client_side_validation and records is None:  # noqa: E501
            raise ValueError("Invalid value for `records`, must not be `None`")  # noqa: E501

        self._records = records

    @property
    def errors(self):
        """Gets the errors of this LookupBimiDomainResults.  # noqa: E501


        :return: The errors of this LookupBimiDomainResults.  # noqa: E501
        :rtype: list[str]
        """
        return self._errors

    @errors.setter
    def errors(self, errors):
        """Sets the errors of this LookupBimiDomainResults.


        :param errors: The errors of this LookupBimiDomainResults.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and errors is None:  # noqa: E501
            raise ValueError("Invalid value for `errors`, must not be `None`")  # noqa: E501

        self._errors = errors

    @property
    def warnings(self):
        """Gets the warnings of this LookupBimiDomainResults.  # noqa: E501


        :return: The warnings of this LookupBimiDomainResults.  # noqa: E501
        :rtype: list[str]
        """
        return self._warnings

    @warnings.setter
    def warnings(self, warnings):
        """Sets the warnings of this LookupBimiDomainResults.


        :param warnings: The warnings of this LookupBimiDomainResults.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and warnings is None:  # noqa: E501
            raise ValueError("Invalid value for `warnings`, must not be `None`")  # noqa: E501

        self._warnings = warnings

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, LookupBimiDomainResults):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, LookupBimiDomainResults):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/lookup_bimi_domain_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class LookupBimiDomainOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'host': 'str'
    }

    attribute_map = {
        'host': 'host'
    }

    def __init__(self, host=None, local_vars_configuration=None):  # noqa: E501
        """LookupBimiDomainOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._host = None
        self.discriminator = None

        self.host = host

    @property
    def host(self):
        """Gets the host of this LookupBimiDomainOptions.  # noqa: E501


        :return: The host of this LookupBimiDomainOptions.  # noqa: E501
        :rtype: str
        """
        return self._host

    @host.setter
    def host(self, host):
        """Sets the host of this LookupBimiDomainOptions.


        :param host: The host of this LookupBimiDomainOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and host is None:  # noqa: E501
            raise ValueError("Invalid value for `host`, must not be `None`")  # noqa: E501

        self._host = host

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, LookupBimiDomainOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, LookupBimiDomainOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/list_unsubscribe_recipient_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ListUnsubscribeRecipientProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'email_address': 'str',
        'domain_id': 'str',
        'id': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'email_address': 'emailAddress',
        'domain_id': 'domainId',
        'id': 'id'
    }

    def __init__(self, created_at=None, email_address=None, domain_id=None, id=None, local_vars_configuration=None):  # noqa: E501
        """ListUnsubscribeRecipientProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._email_address = None
        self._domain_id = None
        self._id = None
        self.discriminator = None

        self.created_at = created_at
        self.email_address = email_address
        self.domain_id = domain_id
        self.id = id

    @property
    def created_at(self):
        """Gets the created_at of this ListUnsubscribeRecipientProjection.  # noqa: E501


        :return: The created_at of this ListUnsubscribeRecipientProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this ListUnsubscribeRecipientProjection.


        :param created_at: The created_at of this ListUnsubscribeRecipientProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def email_address(self):
        """Gets the email_address of this ListUnsubscribeRecipientProjection.  # noqa: E501


        :return: The email_address of this ListUnsubscribeRecipientProjection.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this ListUnsubscribeRecipientProjection.


        :param email_address: The email_address of this ListUnsubscribeRecipientProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    @property
    def domain_id(self):
        """Gets the domain_id of this ListUnsubscribeRecipientProjection.  # noqa: E501


        :return: The domain_id of this ListUnsubscribeRecipientProjection.  # noqa: E501
        :rtype: str
        """
        return self._domain_id

    @domain_id.setter
    def domain_id(self, domain_id):
        """Sets the domain_id of this ListUnsubscribeRecipientProjection.


        :param domain_id: The domain_id of this ListUnsubscribeRecipientProjection.  # noqa: E501
        :type: str
        """

        self._domain_id = domain_id

    @property
    def id(self):
        """Gets the id of this ListUnsubscribeRecipientProjection.  # noqa: E501


        :return: The id of this ListUnsubscribeRecipientProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this ListUnsubscribeRecipientProjection.


        :param id: The id of this ListUnsubscribeRecipientProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ListUnsubscribeRecipientProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ListUnsubscribeRecipientProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/link_issue.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class LinkIssue(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'url': 'str',
        'response_status': 'int',
        'severity': 'str',
        'message': 'str'
    }

    attribute_map = {
        'url': 'url',
        'response_status': 'responseStatus',
        'severity': 'severity',
        'message': 'message'
    }

    def __init__(self, url=None, response_status=None, severity=None, message=None, local_vars_configuration=None):  # noqa: E501
        """LinkIssue - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._url = None
        self._response_status = None
        self._severity = None
        self._message = None
        self.discriminator = None

        self.url = url
        if response_status is not None:
            self.response_status = response_status
        self.severity = severity
        self.message = message

    @property
    def url(self):
        """Gets the url of this LinkIssue.  # noqa: E501


        :return: The url of this LinkIssue.  # noqa: E501
        :rtype: str
        """
        return self._url

    @url.setter
    def url(self, url):
        """Sets the url of this LinkIssue.


        :param url: The url of this LinkIssue.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and url is None:  # noqa: E501
            raise ValueError("Invalid value for `url`, must not be `None`")  # noqa: E501

        self._url = url

    @property
    def response_status(self):
        """Gets the response_status of this LinkIssue.  # noqa: E501


        :return: The response_status of this LinkIssue.  # noqa: E501
        :rtype: int
        """
        return self._response_status

    @response_status.setter
    def response_status(self, response_status):
        """Sets the response_status of this LinkIssue.


        :param response_status: The response_status of this LinkIssue.  # noqa: E501
        :type: int
        """

        self._response_status = response_status

    @property
    def severity(self):
        """Gets the severity of this LinkIssue.  # noqa: E501


        :return: The severity of this LinkIssue.  # noqa: E501
        :rtype: str
        """
        return self._severity

    @severity.setter
    def severity(self, severity):
        """Sets the severity of this LinkIssue.


        :param severity: The severity of this LinkIssue.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and severity is None:  # noqa: E501
            raise ValueError("Invalid value for `severity`, must not be `None`")  # noqa: E501
        allowed_values = ["Warning", "Error"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and severity not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `severity` ({0}), must be one of {1}"  # noqa: E501
                .format(severity, allowed_values)
            )

        self._severity = severity

    @property
    def message(self):
        """Gets the message of this LinkIssue.  # noqa: E501


        :return: The message of this LinkIssue.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this LinkIssue.


        :param message: The message of this LinkIssue.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and message is None:  # noqa: E501
            raise ValueError("Invalid value for `message`, must not be `None`")  # noqa: E501

        self._message = message

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, LinkIssue):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, LinkIssue):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/json_schema_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class JSONSchemaDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'value': 'str'
    }

    attribute_map = {
        'value': 'value'
    }

    def __init__(self, value=None, local_vars_configuration=None):  # noqa: E501
        """JSONSchemaDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._value = None
        self.discriminator = None

        self.value = value

    @property
    def value(self):
        """Gets the value of this JSONSchemaDto.  # noqa: E501


        :return: The value of this JSONSchemaDto.  # noqa: E501
        :rtype: str
        """
        return self._value

    @value.setter
    def value(self, value):
        """Sets the value of this JSONSchemaDto.


        :param value: The value of this JSONSchemaDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and value is None:  # noqa: E501
            raise ValueError("Invalid value for `value`, must not be `None`")  # noqa: E501

        self._value = value

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, JSONSchemaDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, JSONSchemaDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/ip_address_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class IPAddressResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'address': 'str',
        'hostname': 'str'
    }

    attribute_map = {
        'address': 'address',
        'hostname': 'hostname'
    }

    def __init__(self, address=None, hostname=None, local_vars_configuration=None):  # noqa: E501
        """IPAddressResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._address = None
        self._hostname = None
        self.discriminator = None

        self.address = address
        self.hostname = hostname

    @property
    def address(self):
        """Gets the address of this IPAddressResult.  # noqa: E501


        :return: The address of this IPAddressResult.  # noqa: E501
        :rtype: str
        """
        return self._address

    @address.setter
    def address(self, address):
        """Sets the address of this IPAddressResult.


        :param address: The address of this IPAddressResult.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and address is None:  # noqa: E501
            raise ValueError("Invalid value for `address`, must not be `None`")  # noqa: E501

        self._address = address

    @property
    def hostname(self):
        """Gets the hostname of this IPAddressResult.  # noqa: E501


        :return: The hostname of this IPAddressResult.  # noqa: E501
        :rtype: str
        """
        return self._hostname

    @hostname.setter
    def hostname(self, hostname):
        """Sets the hostname of this IPAddressResult.


        :param hostname: The hostname of this IPAddressResult.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and hostname is None:  # noqa: E501
            raise ValueError("Invalid value for `hostname`, must not be `None`")  # noqa: E501

        self._hostname = hostname

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, IPAddressResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, IPAddressResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inline_object.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InlineObject(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content_type_header': 'str',
        'file': 'file'
    }

    attribute_map = {
        'content_type_header': 'contentTypeHeader',
        'file': 'file'
    }

    def __init__(self, content_type_header=None, file=None, local_vars_configuration=None):  # noqa: E501
        """InlineObject - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content_type_header = None
        self._file = None
        self.discriminator = None

        if content_type_header is not None:
            self.content_type_header = content_type_header
        self.file = file

    @property
    def content_type_header(self):
        """Gets the content_type_header of this InlineObject.  # noqa: E501

        Optional content type header of attachment  # noqa: E501

        :return: The content_type_header of this InlineObject.  # noqa: E501
        :rtype: str
        """
        return self._content_type_header

    @content_type_header.setter
    def content_type_header(self, content_type_header):
        """Sets the content_type_header of this InlineObject.

        Optional content type header of attachment  # noqa: E501

        :param content_type_header: The content_type_header of this InlineObject.  # noqa: E501
        :type: str
        """

        self._content_type_header = content_type_header

    @property
    def file(self):
        """Gets the file of this InlineObject.  # noqa: E501


        :return: The file of this InlineObject.  # noqa: E501
        :rtype: file
        """
        return self._file

    @file.setter
    def file(self, file):
        """Sets the file of this InlineObject.


        :param file: The file of this InlineObject.  # noqa: E501
        :type: file
        """
        if self.local_vars_configuration.client_side_validation and file is None:  # noqa: E501
            raise ValueError("Invalid value for `file`, must not be `None`")  # noqa: E501

        self._file = file

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InlineObject):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InlineObject):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_ruleset_test_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxRulesetTestResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'ruleset_matches': 'dict(str, bool)',
        'matches': 'bool'
    }

    attribute_map = {
        'ruleset_matches': 'rulesetMatches',
        'matches': 'matches'
    }

    def __init__(self, ruleset_matches=None, matches=None, local_vars_configuration=None):  # noqa: E501
        """InboxRulesetTestResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._ruleset_matches = None
        self._matches = None
        self.discriminator = None

        self.ruleset_matches = ruleset_matches
        self.matches = matches

    @property
    def ruleset_matches(self):
        """Gets the ruleset_matches of this InboxRulesetTestResult.  # noqa: E501

        Map of inbox ruleset ID to boolean of if target matches  # noqa: E501

        :return: The ruleset_matches of this InboxRulesetTestResult.  # noqa: E501
        :rtype: dict(str, bool)
        """
        return self._ruleset_matches

    @ruleset_matches.setter
    def ruleset_matches(self, ruleset_matches):
        """Sets the ruleset_matches of this InboxRulesetTestResult.

        Map of inbox ruleset ID to boolean of if target matches  # noqa: E501

        :param ruleset_matches: The ruleset_matches of this InboxRulesetTestResult.  # noqa: E501
        :type: dict(str, bool)
        """
        if self.local_vars_configuration.client_side_validation and ruleset_matches is None:  # noqa: E501
            raise ValueError("Invalid value for `ruleset_matches`, must not be `None`")  # noqa: E501

        self._ruleset_matches = ruleset_matches

    @property
    def matches(self):
        """Gets the matches of this InboxRulesetTestResult.  # noqa: E501


        :return: The matches of this InboxRulesetTestResult.  # noqa: E501
        :rtype: bool
        """
        return self._matches

    @matches.setter
    def matches(self, matches):
        """Sets the matches of this InboxRulesetTestResult.


        :param matches: The matches of this InboxRulesetTestResult.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and matches is None:  # noqa: E501
            raise ValueError("Invalid value for `matches`, must not be `None`")  # noqa: E501

        self._matches = matches

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxRulesetTestResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxRulesetTestResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_ruleset_test_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxRulesetTestOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'test_target': 'str'
    }

    attribute_map = {
        'test_target': 'testTarget'
    }

    def __init__(self, test_target=None, local_vars_configuration=None):  # noqa: E501
        """InboxRulesetTestOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._test_target = None
        self.discriminator = None

        self.test_target = test_target

    @property
    def test_target(self):
        """Gets the test_target of this InboxRulesetTestOptions.  # noqa: E501


        :return: The test_target of this InboxRulesetTestOptions.  # noqa: E501
        :rtype: str
        """
        return self._test_target

    @test_target.setter
    def test_target(self, test_target):
        """Sets the test_target of this InboxRulesetTestOptions.


        :param test_target: The test_target of this InboxRulesetTestOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and test_target is None:  # noqa: E501
            raise ValueError("Invalid value for `test_target`, must not be `None`")  # noqa: E501

        self._test_target = test_target

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxRulesetTestOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxRulesetTestOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_ruleset_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxRulesetDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'inbox_id': 'str',
        'scope': 'str',
        'action': 'str',
        'target': 'str',
        'handler': 'str',
        'created_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'inbox_id': 'inboxId',
        'scope': 'scope',
        'action': 'action',
        'target': 'target',
        'handler': 'handler',
        'created_at': 'createdAt'
    }

    def __init__(self, id=None, inbox_id=None, scope=None, action=None, target=None, handler=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """InboxRulesetDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._inbox_id = None
        self._scope = None
        self._action = None
        self._target = None
        self._handler = None
        self._created_at = None
        self.discriminator = None

        self.id = id
        self.inbox_id = inbox_id
        self.scope = scope
        self.action = action
        self.target = target
        self.handler = handler
        self.created_at = created_at

    @property
    def id(self):
        """Gets the id of this InboxRulesetDto.  # noqa: E501


        :return: The id of this InboxRulesetDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this InboxRulesetDto.


        :param id: The id of this InboxRulesetDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def inbox_id(self):
        """Gets the inbox_id of this InboxRulesetDto.  # noqa: E501


        :return: The inbox_id of this InboxRulesetDto.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this InboxRulesetDto.


        :param inbox_id: The inbox_id of this InboxRulesetDto.  # noqa: E501
        :type: str
        """

        self._inbox_id = inbox_id

    @property
    def scope(self):
        """Gets the scope of this InboxRulesetDto.  # noqa: E501


        :return: The scope of this InboxRulesetDto.  # noqa: E501
        :rtype: str
        """
        return self._scope

    @scope.setter
    def scope(self, scope):
        """Sets the scope of this InboxRulesetDto.


        :param scope: The scope of this InboxRulesetDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and scope is None:  # noqa: E501
            raise ValueError("Invalid value for `scope`, must not be `None`")  # noqa: E501
        allowed_values = ["RECEIVING_EMAILS", "SENDING_EMAILS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and scope not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `scope` ({0}), must be one of {1}"  # noqa: E501
                .format(scope, allowed_values)
            )

        self._scope = scope

    @property
    def action(self):
        """Gets the action of this InboxRulesetDto.  # noqa: E501


        :return: The action of this InboxRulesetDto.  # noqa: E501
        :rtype: str
        """
        return self._action

    @action.setter
    def action(self, action):
        """Sets the action of this InboxRulesetDto.


        :param action: The action of this InboxRulesetDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and action is None:  # noqa: E501
            raise ValueError("Invalid value for `action`, must not be `None`")  # noqa: E501
        allowed_values = ["BLOCK", "ALLOW", "FILTER_REMOVE"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and action not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `action` ({0}), must be one of {1}"  # noqa: E501
                .format(action, allowed_values)
            )

        self._action = action

    @property
    def target(self):
        """Gets the target of this InboxRulesetDto.  # noqa: E501


        :return: The target of this InboxRulesetDto.  # noqa: E501
        :rtype: str
        """
        return self._target

    @target.setter
    def target(self, target):
        """Sets the target of this InboxRulesetDto.


        :param target: The target of this InboxRulesetDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and target is None:  # noqa: E501
            raise ValueError("Invalid value for `target`, must not be `None`")  # noqa: E501

        self._target = target

    @property
    def handler(self):
        """Gets the handler of this InboxRulesetDto.  # noqa: E501


        :return: The handler of this InboxRulesetDto.  # noqa: E501
        :rtype: str
        """
        return self._handler

    @handler.setter
    def handler(self, handler):
        """Sets the handler of this InboxRulesetDto.


        :param handler: The handler of this InboxRulesetDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and handler is None:  # noqa: E501
            raise ValueError("Invalid value for `handler`, must not be `None`")  # noqa: E501
        allowed_values = ["EXCEPTION"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and handler not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `handler` ({0}), must be one of {1}"  # noqa: E501
                .format(handler, allowed_values)
            )

        self._handler = handler

    @property
    def created_at(self):
        """Gets the created_at of this InboxRulesetDto.  # noqa: E501


        :return: The created_at of this InboxRulesetDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this InboxRulesetDto.


        :param created_at: The created_at of this InboxRulesetDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxRulesetDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxRulesetDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_replier_event_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxReplierEventProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'replier_id': 'str',
        'recipients': 'list[str]',
        'email_id': 'str',
        'inbox_id': 'str',
        'user_id': 'str',
        'sent_id': 'str',
        'message': 'str',
        'id': 'str',
        'status': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'replier_id': 'replierId',
        'recipients': 'recipients',
        'email_id': 'emailId',
        'inbox_id': 'inboxId',
        'user_id': 'userId',
        'sent_id': 'sentId',
        'message': 'message',
        'id': 'id',
        'status': 'status'
    }

    def __init__(self, created_at=None, replier_id=None, recipients=None, email_id=None, inbox_id=None, user_id=None, sent_id=None, message=None, id=None, status=None, local_vars_configuration=None):  # noqa: E501
        """InboxReplierEventProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._replier_id = None
        self._recipients = None
        self._email_id = None
        self._inbox_id = None
        self._user_id = None
        self._sent_id = None
        self._message = None
        self._id = None
        self._status = None
        self.discriminator = None

        self.created_at = created_at
        self.replier_id = replier_id
        self.recipients = recipients
        self.email_id = email_id
        self.inbox_id = inbox_id
        self.user_id = user_id
        self.sent_id = sent_id
        self.message = message
        self.id = id
        self.status = status

    @property
    def created_at(self):
        """Gets the created_at of this InboxReplierEventProjection.  # noqa: E501


        :return: The created_at of this InboxReplierEventProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this InboxReplierEventProjection.


        :param created_at: The created_at of this InboxReplierEventProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def replier_id(self):
        """Gets the replier_id of this InboxReplierEventProjection.  # noqa: E501


        :return: The replier_id of this InboxReplierEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._replier_id

    @replier_id.setter
    def replier_id(self, replier_id):
        """Sets the replier_id of this InboxReplierEventProjection.


        :param replier_id: The replier_id of this InboxReplierEventProjection.  # noqa: E501
        :type: str
        """

        self._replier_id = replier_id

    @property
    def recipients(self):
        """Gets the recipients of this InboxReplierEventProjection.  # noqa: E501


        :return: The recipients of this InboxReplierEventProjection.  # noqa: E501
        :rtype: list[str]
        """
        return self._recipients

    @recipients.setter
    def recipients(self, recipients):
        """Sets the recipients of this InboxReplierEventProjection.


        :param recipients: The recipients of this InboxReplierEventProjection.  # noqa: E501
        :type: list[str]
        """

        self._recipients = recipients

    @property
    def email_id(self):
        """Gets the email_id of this InboxReplierEventProjection.  # noqa: E501


        :return: The email_id of this InboxReplierEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._email_id

    @email_id.setter
    def email_id(self, email_id):
        """Sets the email_id of this InboxReplierEventProjection.


        :param email_id: The email_id of this InboxReplierEventProjection.  # noqa: E501
        :type: str
        """

        self._email_id = email_id

    @property
    def inbox_id(self):
        """Gets the inbox_id of this InboxReplierEventProjection.  # noqa: E501


        :return: The inbox_id of this InboxReplierEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this InboxReplierEventProjection.


        :param inbox_id: The inbox_id of this InboxReplierEventProjection.  # noqa: E501
        :type: str
        """

        self._inbox_id = inbox_id

    @property
    def user_id(self):
        """Gets the user_id of this InboxReplierEventProjection.  # noqa: E501


        :return: The user_id of this InboxReplierEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this InboxReplierEventProjection.


        :param user_id: The user_id of this InboxReplierEventProjection.  # noqa: E501
        :type: str
        """

        self._user_id = user_id

    @property
    def sent_id(self):
        """Gets the sent_id of this InboxReplierEventProjection.  # noqa: E501


        :return: The sent_id of this InboxReplierEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._sent_id

    @sent_id.setter
    def sent_id(self, sent_id):
        """Sets the sent_id of this InboxReplierEventProjection.


        :param sent_id: The sent_id of this InboxReplierEventProjection.  # noqa: E501
        :type: str
        """

        self._sent_id = sent_id

    @property
    def message(self):
        """Gets the message of this InboxReplierEventProjection.  # noqa: E501


        :return: The message of this InboxReplierEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this InboxReplierEventProjection.


        :param message: The message of this InboxReplierEventProjection.  # noqa: E501
        :type: str
        """

        self._message = message

    @property
    def id(self):
        """Gets the id of this InboxReplierEventProjection.  # noqa: E501


        :return: The id of this InboxReplierEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this InboxReplierEventProjection.


        :param id: The id of this InboxReplierEventProjection.  # noqa: E501
        :type: str
        """

        self._id = id

    @property
    def status(self):
        """Gets the status of this InboxReplierEventProjection.  # noqa: E501


        :return: The status of this InboxReplierEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._status

    @status.setter
    def status(self, status):
        """Sets the status of this InboxReplierEventProjection.


        :param status: The status of this InboxReplierEventProjection.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"SUCCESS", "FAILURE"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and status not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `status` ({0}), must be one of {1}"  # noqa: E501
                .format(status, allowed_values)
            )

        self._status = status

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxReplierEventProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxReplierEventProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_replier_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxReplierDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'inbox_id': 'str',
        'name': 'str',
        'field': 'str',
        'match': 'str',
        'reply_to': 'str',
        'subject': 'str',
        '_from': 'str',
        'charset': 'str',
        'is_html': 'bool',
        'template_id': 'str',
        'template_variables': 'dict(str, object)',
        'ignore_reply_to': 'bool',
        'created_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'inbox_id': 'inboxId',
        'name': 'name',
        'field': 'field',
        'match': 'match',
        'reply_to': 'replyTo',
        'subject': 'subject',
        '_from': 'from',
        'charset': 'charset',
        'is_html': 'isHTML',
        'template_id': 'templateId',
        'template_variables': 'templateVariables',
        'ignore_reply_to': 'ignoreReplyTo',
        'created_at': 'createdAt'
    }

    def __init__(self, id=None, inbox_id=None, name=None, field=None, match=None, reply_to=None, subject=None, _from=None, charset=None, is_html=None, template_id=None, template_variables=None, ignore_reply_to=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """InboxReplierDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._inbox_id = None
        self._name = None
        self._field = None
        self._match = None
        self._reply_to = None
        self._subject = None
        self.__from = None
        self._charset = None
        self._is_html = None
        self._template_id = None
        self._template_variables = None
        self._ignore_reply_to = None
        self._created_at = None
        self.discriminator = None

        self.id = id
        self.inbox_id = inbox_id
        self.name = name
        self.field = field
        self.match = match
        self.reply_to = reply_to
        self.subject = subject
        self._from = _from
        self.charset = charset
        self.is_html = is_html
        self.template_id = template_id
        self.template_variables = template_variables
        self.ignore_reply_to = ignore_reply_to
        self.created_at = created_at

    @property
    def id(self):
        """Gets the id of this InboxReplierDto.  # noqa: E501


        :return: The id of this InboxReplierDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this InboxReplierDto.


        :param id: The id of this InboxReplierDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def inbox_id(self):
        """Gets the inbox_id of this InboxReplierDto.  # noqa: E501


        :return: The inbox_id of this InboxReplierDto.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this InboxReplierDto.


        :param inbox_id: The inbox_id of this InboxReplierDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def name(self):
        """Gets the name of this InboxReplierDto.  # noqa: E501


        :return: The name of this InboxReplierDto.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this InboxReplierDto.


        :param name: The name of this InboxReplierDto.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def field(self):
        """Gets the field of this InboxReplierDto.  # noqa: E501


        :return: The field of this InboxReplierDto.  # noqa: E501
        :rtype: str
        """
        return self._field

    @field.setter
    def field(self, field):
        """Sets the field of this InboxReplierDto.


        :param field: The field of this InboxReplierDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and field is None:  # noqa: E501
            raise ValueError("Invalid value for `field`, must not be `None`")  # noqa: E501
        allowed_values = ["RECIPIENTS", "SENDER", "SUBJECT", "ATTACHMENTS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and field not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `field` ({0}), must be one of {1}"  # noqa: E501
                .format(field, allowed_values)
            )

        self._field = field

    @property
    def match(self):
        """Gets the match of this InboxReplierDto.  # noqa: E501


        :return: The match of this InboxReplierDto.  # noqa: E501
        :rtype: str
        """
        return self._match

    @match.setter
    def match(self, match):
        """Sets the match of this InboxReplierDto.


        :param match: The match of this InboxReplierDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and match is None:  # noqa: E501
            raise ValueError("Invalid value for `match`, must not be `None`")  # noqa: E501

        self._match = match

    @property
    def reply_to(self):
        """Gets the reply_to of this InboxReplierDto.  # noqa: E501


        :return: The reply_to of this InboxReplierDto.  # noqa: E501
        :rtype: str
        """
        return self._reply_to

    @reply_to.setter
    def reply_to(self, reply_to):
        """Sets the reply_to of this InboxReplierDto.


        :param reply_to: The reply_to of this InboxReplierDto.  # noqa: E501
        :type: str
        """

        self._reply_to = reply_to

    @property
    def subject(self):
        """Gets the subject of this InboxReplierDto.  # noqa: E501


        :return: The subject of this InboxReplierDto.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this InboxReplierDto.


        :param subject: The subject of this InboxReplierDto.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def _from(self):
        """Gets the _from of this InboxReplierDto.  # noqa: E501


        :return: The _from of this InboxReplierDto.  # noqa: E501
        :rtype: str
        """
        return self.__from

    @_from.setter
    def _from(self, _from):
        """Sets the _from of this InboxReplierDto.


        :param _from: The _from of this InboxReplierDto.  # noqa: E501
        :type: str
        """

        self.__from = _from

    @property
    def charset(self):
        """Gets the charset of this InboxReplierDto.  # noqa: E501


        :return: The charset of this InboxReplierDto.  # noqa: E501
        :rtype: str
        """
        return self._charset

    @charset.setter
    def charset(self, charset):
        """Sets the charset of this InboxReplierDto.


        :param charset: The charset of this InboxReplierDto.  # noqa: E501
        :type: str
        """

        self._charset = charset

    @property
    def is_html(self):
        """Gets the is_html of this InboxReplierDto.  # noqa: E501


        :return: The is_html of this InboxReplierDto.  # noqa: E501
        :rtype: bool
        """
        return self._is_html

    @is_html.setter
    def is_html(self, is_html):
        """Sets the is_html of this InboxReplierDto.


        :param is_html: The is_html of this InboxReplierDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and is_html is None:  # noqa: E501
            raise ValueError("Invalid value for `is_html`, must not be `None`")  # noqa: E501

        self._is_html = is_html

    @property
    def template_id(self):
        """Gets the template_id of this InboxReplierDto.  # noqa: E501


        :return: The template_id of this InboxReplierDto.  # noqa: E501
        :rtype: str
        """
        return self._template_id

    @template_id.setter
    def template_id(self, template_id):
        """Sets the template_id of this InboxReplierDto.


        :param template_id: The template_id of this InboxReplierDto.  # noqa: E501
        :type: str
        """

        self._template_id = template_id

    @property
    def template_variables(self):
        """Gets the template_variables of this InboxReplierDto.  # noqa: E501


        :return: The template_variables of this InboxReplierDto.  # noqa: E501
        :rtype: dict(str, object)
        """
        return self._template_variables

    @template_variables.setter
    def template_variables(self, template_variables):
        """Sets the template_variables of this InboxReplierDto.


        :param template_variables: The template_variables of this InboxReplierDto.  # noqa: E501
        :type: dict(str, object)
        """

        self._template_variables = template_variables

    @property
    def ignore_reply_to(self):
        """Gets the ignore_reply_to of this InboxReplierDto.  # noqa: E501


        :return: The ignore_reply_to of this InboxReplierDto.  # noqa: E501
        :rtype: bool
        """
        return self._ignore_reply_to

    @ignore_reply_to.setter
    def ignore_reply_to(self, ignore_reply_to):
        """Sets the ignore_reply_to of this InboxReplierDto.


        :param ignore_reply_to: The ignore_reply_to of this InboxReplierDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and ignore_reply_to is None:  # noqa: E501
            raise ValueError("Invalid value for `ignore_reply_to`, must not be `None`")  # noqa: E501

        self._ignore_reply_to = ignore_reply_to

    @property
    def created_at(self):
        """Gets the created_at of this InboxReplierDto.  # noqa: E501


        :return: The created_at of this InboxReplierDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this InboxReplierDto.


        :param created_at: The created_at of this InboxReplierDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxReplierDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxReplierDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_preview.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxPreview(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'domain_id': 'str',
        'email_address': 'str',
        'created_at': 'datetime',
        'favourite': 'bool',
        'name': 'str',
        'tags': 'list[str]',
        'team_access': 'bool',
        'inbox_type': 'str',
        'virtual_inbox': 'bool',
        'expires_at': 'str',
        'functions_as': 'str'
    }

    attribute_map = {
        'id': 'id',
        'domain_id': 'domainId',
        'email_address': 'emailAddress',
        'created_at': 'createdAt',
        'favourite': 'favourite',
        'name': 'name',
        'tags': 'tags',
        'team_access': 'teamAccess',
        'inbox_type': 'inboxType',
        'virtual_inbox': 'virtualInbox',
        'expires_at': 'expiresAt',
        'functions_as': 'functionsAs'
    }

    def __init__(self, id=None, domain_id=None, email_address=None, created_at=None, favourite=None, name=None, tags=None, team_access=None, inbox_type=None, virtual_inbox=None, expires_at=None, functions_as=None, local_vars_configuration=None):  # noqa: E501
        """InboxPreview - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._domain_id = None
        self._email_address = None
        self._created_at = None
        self._favourite = None
        self._name = None
        self._tags = None
        self._team_access = None
        self._inbox_type = None
        self._virtual_inbox = None
        self._expires_at = None
        self._functions_as = None
        self.discriminator = None

        self.id = id
        self.domain_id = domain_id
        self.email_address = email_address
        self.created_at = created_at
        self.favourite = favourite
        self.name = name
        self.tags = tags
        self.team_access = team_access
        self.inbox_type = inbox_type
        self.virtual_inbox = virtual_inbox
        self.expires_at = expires_at
        self.functions_as = functions_as

    @property
    def id(self):
        """Gets the id of this InboxPreview.  # noqa: E501

        ID of the inbox. The ID is a UUID-V4 format string. Use the inboxId for calls to Inbox and Email Controller endpoints. See the emailAddress property for the email address or the inbox. To get emails in an inbox use the WaitFor and Inbox Controller methods `waitForLatestEmail` and `getEmails` methods respectively. Inboxes can be used with aliases to forward emails automatically.  # noqa: E501

        :return: The id of this InboxPreview.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this InboxPreview.

        ID of the inbox. The ID is a UUID-V4 format string. Use the inboxId for calls to Inbox and Email Controller endpoints. See the emailAddress property for the email address or the inbox. To get emails in an inbox use the WaitFor and Inbox Controller methods `waitForLatestEmail` and `getEmails` methods respectively. Inboxes can be used with aliases to forward emails automatically.  # noqa: E501

        :param id: The id of this InboxPreview.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def domain_id(self):
        """Gets the domain_id of this InboxPreview.  # noqa: E501

        ID of custom domain used by the inbox if any  # noqa: E501

        :return: The domain_id of this InboxPreview.  # noqa: E501
        :rtype: str
        """
        return self._domain_id

    @domain_id.setter
    def domain_id(self, domain_id):
        """Sets the domain_id of this InboxPreview.

        ID of custom domain used by the inbox if any  # noqa: E501

        :param domain_id: The domain_id of this InboxPreview.  # noqa: E501
        :type: str
        """

        self._domain_id = domain_id

    @property
    def email_address(self):
        """Gets the email_address of this InboxPreview.  # noqa: E501

        The inbox's email address. Inbox projections and previews may not include the email address. To view the email address fetch the inbox entity directly. Send an email to this address and the inbox will receive and store it for you. Note the email address in MailSlurp match characters exactly and are case sensitive so `+123` additions are considered different addresses. To retrieve the email use the Inbox and Email Controller endpoints with the inbox ID.  # noqa: E501

        :return: The email_address of this InboxPreview.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this InboxPreview.

        The inbox's email address. Inbox projections and previews may not include the email address. To view the email address fetch the inbox entity directly. Send an email to this address and the inbox will receive and store it for you. Note the email address in MailSlurp match characters exactly and are case sensitive so `+123` additions are considered different addresses. To retrieve the email use the Inbox and Email Controller endpoints with the inbox ID.  # noqa: E501

        :param email_address: The email_address of this InboxPreview.  # noqa: E501
        :type: str
        """

        self._email_address = email_address

    @property
    def created_at(self):
        """Gets the created_at of this InboxPreview.  # noqa: E501

        When the inbox was created. Time stamps are in ISO DateTime Format `yyyy-MM-dd'T'HH:mm:ss.SSSXXX` e.g. `2000-10-31T01:30:00.000-05:00`.  # noqa: E501

        :return: The created_at of this InboxPreview.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this InboxPreview.

        When the inbox was created. Time stamps are in ISO DateTime Format `yyyy-MM-dd'T'HH:mm:ss.SSSXXX` e.g. `2000-10-31T01:30:00.000-05:00`.  # noqa: E501

        :param created_at: The created_at of this InboxPreview.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def favourite(self):
        """Gets the favourite of this InboxPreview.  # noqa: E501

        Is the inbox a favorite inbox. Make an inbox a favorite is typically done in the dashboard for quick access or filtering  # noqa: E501

        :return: The favourite of this InboxPreview.  # noqa: E501
        :rtype: bool
        """
        return self._favourite

    @favourite.setter
    def favourite(self, favourite):
        """Sets the favourite of this InboxPreview.

        Is the inbox a favorite inbox. Make an inbox a favorite is typically done in the dashboard for quick access or filtering  # noqa: E501

        :param favourite: The favourite of this InboxPreview.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and favourite is None:  # noqa: E501
            raise ValueError("Invalid value for `favourite`, must not be `None`")  # noqa: E501

        self._favourite = favourite

    @property
    def name(self):
        """Gets the name of this InboxPreview.  # noqa: E501

        Name of the inbox and used as the sender name when sending emails .Displayed in the dashboard for easier search  # noqa: E501

        :return: The name of this InboxPreview.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this InboxPreview.

        Name of the inbox and used as the sender name when sending emails .Displayed in the dashboard for easier search  # noqa: E501

        :param name: The name of this InboxPreview.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def tags(self):
        """Gets the tags of this InboxPreview.  # noqa: E501

        Tags that inbox has been tagged with. Tags can be added to inboxes to group different inboxes within an account. You can also search for inboxes by tag in the dashboard UI.  # noqa: E501

        :return: The tags of this InboxPreview.  # noqa: E501
        :rtype: list[str]
        """
        return self._tags

    @tags.setter
    def tags(self, tags):
        """Sets the tags of this InboxPreview.

        Tags that inbox has been tagged with. Tags can be added to inboxes to group different inboxes within an account. You can also search for inboxes by tag in the dashboard UI.  # noqa: E501

        :param tags: The tags of this InboxPreview.  # noqa: E501
        :type: list[str]
        """

        self._tags = tags

    @property
    def team_access(self):
        """Gets the team_access of this InboxPreview.  # noqa: E501

        Does inbox permit team access for organization team members. If so team users can use inbox and emails associated with it. See the team access guide at https://www.mailslurp.com/guides/team-email-account-sharing/  # noqa: E501

        :return: The team_access of this InboxPreview.  # noqa: E501
        :rtype: bool
        """
        return self._team_access

    @team_access.setter
    def team_access(self, team_access):
        """Sets the team_access of this InboxPreview.

        Does inbox permit team access for organization team members. If so team users can use inbox and emails associated with it. See the team access guide at https://www.mailslurp.com/guides/team-email-account-sharing/  # noqa: E501

        :param team_access: The team_access of this InboxPreview.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and team_access is None:  # noqa: E501
            raise ValueError("Invalid value for `team_access`, must not be `None`")  # noqa: E501

        self._team_access = team_access

    @property
    def inbox_type(self):
        """Gets the inbox_type of this InboxPreview.  # noqa: E501

        Type of inbox. HTTP inboxes are faster and better for most cases. SMTP inboxes are more suited for public facing inbound messages (but cannot send).  # noqa: E501

        :return: The inbox_type of this InboxPreview.  # noqa: E501
        :rtype: str
        """
        return self._inbox_type

    @inbox_type.setter
    def inbox_type(self, inbox_type):
        """Sets the inbox_type of this InboxPreview.

        Type of inbox. HTTP inboxes are faster and better for most cases. SMTP inboxes are more suited for public facing inbound messages (but cannot send).  # noqa: E501

        :param inbox_type: The inbox_type of this InboxPreview.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"HTTP_INBOX", "SMTP_INBOX"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and inbox_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `inbox_type` ({0}), must be one of {1}"  # noqa: E501
                .format(inbox_type, allowed_values)
            )

        self._inbox_type = inbox_type

    @property
    def virtual_inbox(self):
        """Gets the virtual_inbox of this InboxPreview.  # noqa: E501

        Virtual inbox can receive email but will not send emails to real recipients. Will save sent email record but never send an actual email. Perfect for testing mail server actions.  # noqa: E501

        :return: The virtual_inbox of this InboxPreview.  # noqa: E501
        :rtype: bool
        """
        return self._virtual_inbox

    @virtual_inbox.setter
    def virtual_inbox(self, virtual_inbox):
        """Sets the virtual_inbox of this InboxPreview.

        Virtual inbox can receive email but will not send emails to real recipients. Will save sent email record but never send an actual email. Perfect for testing mail server actions.  # noqa: E501

        :param virtual_inbox: The virtual_inbox of this InboxPreview.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and virtual_inbox is None:  # noqa: E501
            raise ValueError("Invalid value for `virtual_inbox`, must not be `None`")  # noqa: E501

        self._virtual_inbox = virtual_inbox

    @property
    def expires_at(self):
        """Gets the expires_at of this InboxPreview.  # noqa: E501

        Inbox expiration time. When, if ever, the inbox should expire and be deleted. If null then this inbox is permanent and the emails in it won't be deleted. This is the default behavior unless expiration date is set. If an expiration date is set and the time is reached MailSlurp will expire the inbox and move it to an expired inbox entity. You can still access the emails belonging to it but it can no longer send or receive email.  # noqa: E501

        :return: The expires_at of this InboxPreview.  # noqa: E501
        :rtype: str
        """
        return self._expires_at

    @expires_at.setter
    def expires_at(self, expires_at):
        """Sets the expires_at of this InboxPreview.

        Inbox expiration time. When, if ever, the inbox should expire and be deleted. If null then this inbox is permanent and the emails in it won't be deleted. This is the default behavior unless expiration date is set. If an expiration date is set and the time is reached MailSlurp will expire the inbox and move it to an expired inbox entity. You can still access the emails belonging to it but it can no longer send or receive email.  # noqa: E501

        :param expires_at: The expires_at of this InboxPreview.  # noqa: E501
        :type: str
        """

        self._expires_at = expires_at

    @property
    def functions_as(self):
        """Gets the functions_as of this InboxPreview.  # noqa: E501

        Inbox function if used as a primitive for another system.  # noqa: E501

        :return: The functions_as of this InboxPreview.  # noqa: E501
        :rtype: str
        """
        return self._functions_as

    @functions_as.setter
    def functions_as(self, functions_as):
        """Sets the functions_as of this InboxPreview.

        Inbox function if used as a primitive for another system.  # noqa: E501

        :param functions_as: The functions_as of this InboxPreview.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"ALIAS", "THREAD", "CATCH_ALL", "CONNECTOR"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and functions_as not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `functions_as` ({0}), must be one of {1}"  # noqa: E501
                .format(functions_as, allowed_values)
            )

        self._functions_as = functions_as

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxPreview):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxPreview):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_ids_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxIdsResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'inbox_ids': 'list[InboxIdItem]'
    }

    attribute_map = {
        'inbox_ids': 'inboxIds'
    }

    def __init__(self, inbox_ids=None, local_vars_configuration=None):  # noqa: E501
        """InboxIdsResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._inbox_ids = None
        self.discriminator = None

        self.inbox_ids = inbox_ids

    @property
    def inbox_ids(self):
        """Gets the inbox_ids of this InboxIdsResult.  # noqa: E501


        :return: The inbox_ids of this InboxIdsResult.  # noqa: E501
        :rtype: list[InboxIdItem]
        """
        return self._inbox_ids

    @inbox_ids.setter
    def inbox_ids(self, inbox_ids):
        """Sets the inbox_ids of this InboxIdsResult.


        :param inbox_ids: The inbox_ids of this InboxIdsResult.  # noqa: E501
        :type: list[InboxIdItem]
        """
        if self.local_vars_configuration.client_side_validation and inbox_ids is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_ids`, must not be `None`")  # noqa: E501

        self._inbox_ids = inbox_ids

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxIdsResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxIdsResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_id_item.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxIdItem(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'email_address': 'str'
    }

    attribute_map = {
        'id': 'id',
        'email_address': 'emailAddress'
    }

    def __init__(self, id=None, email_address=None, local_vars_configuration=None):  # noqa: E501
        """InboxIdItem - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._email_address = None
        self.discriminator = None

        self.id = id
        self.email_address = email_address

    @property
    def id(self):
        """Gets the id of this InboxIdItem.  # noqa: E501


        :return: The id of this InboxIdItem.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this InboxIdItem.


        :param id: The id of this InboxIdItem.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def email_address(self):
        """Gets the email_address of this InboxIdItem.  # noqa: E501


        :return: The email_address of this InboxIdItem.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this InboxIdItem.


        :param email_address: The email_address of this InboxIdItem.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxIdItem):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxIdItem):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_forwarder_test_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxForwarderTestResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'matches': 'dict(str, bool)',
        'does_match': 'bool'
    }

    attribute_map = {
        'matches': 'matches',
        'does_match': 'doesMatch'
    }

    def __init__(self, matches=None, does_match=None, local_vars_configuration=None):  # noqa: E501
        """InboxForwarderTestResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._matches = None
        self._does_match = None
        self.discriminator = None

        self.matches = matches
        self.does_match = does_match

    @property
    def matches(self):
        """Gets the matches of this InboxForwarderTestResult.  # noqa: E501


        :return: The matches of this InboxForwarderTestResult.  # noqa: E501
        :rtype: dict(str, bool)
        """
        return self._matches

    @matches.setter
    def matches(self, matches):
        """Sets the matches of this InboxForwarderTestResult.


        :param matches: The matches of this InboxForwarderTestResult.  # noqa: E501
        :type: dict(str, bool)
        """
        if self.local_vars_configuration.client_side_validation and matches is None:  # noqa: E501
            raise ValueError("Invalid value for `matches`, must not be `None`")  # noqa: E501

        self._matches = matches

    @property
    def does_match(self):
        """Gets the does_match of this InboxForwarderTestResult.  # noqa: E501


        :return: The does_match of this InboxForwarderTestResult.  # noqa: E501
        :rtype: bool
        """
        return self._does_match

    @does_match.setter
    def does_match(self, does_match):
        """Sets the does_match of this InboxForwarderTestResult.


        :param does_match: The does_match of this InboxForwarderTestResult.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and does_match is None:  # noqa: E501
            raise ValueError("Invalid value for `does_match`, must not be `None`")  # noqa: E501

        self._does_match = does_match

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxForwarderTestResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxForwarderTestResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_forwarder_test_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxForwarderTestOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'test_value': 'str'
    }

    attribute_map = {
        'test_value': 'testValue'
    }

    def __init__(self, test_value=None, local_vars_configuration=None):  # noqa: E501
        """InboxForwarderTestOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._test_value = None
        self.discriminator = None

        self.test_value = test_value

    @property
    def test_value(self):
        """Gets the test_value of this InboxForwarderTestOptions.  # noqa: E501


        :return: The test_value of this InboxForwarderTestOptions.  # noqa: E501
        :rtype: str
        """
        return self._test_value

    @test_value.setter
    def test_value(self, test_value):
        """Sets the test_value of this InboxForwarderTestOptions.


        :param test_value: The test_value of this InboxForwarderTestOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and test_value is None:  # noqa: E501
            raise ValueError("Invalid value for `test_value`, must not be `None`")  # noqa: E501

        self._test_value = test_value

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxForwarderTestOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxForwarderTestOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_forwarder_event_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxForwarderEventProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'email_id': 'str',
        'inbox_id': 'str',
        'user_id': 'str',
        'forwarder_id': 'str',
        'message': 'str',
        'id': 'str',
        'status': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'email_id': 'emailId',
        'inbox_id': 'inboxId',
        'user_id': 'userId',
        'forwarder_id': 'forwarderId',
        'message': 'message',
        'id': 'id',
        'status': 'status'
    }

    def __init__(self, created_at=None, email_id=None, inbox_id=None, user_id=None, forwarder_id=None, message=None, id=None, status=None, local_vars_configuration=None):  # noqa: E501
        """InboxForwarderEventProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._email_id = None
        self._inbox_id = None
        self._user_id = None
        self._forwarder_id = None
        self._message = None
        self._id = None
        self._status = None
        self.discriminator = None

        self.created_at = created_at
        self.email_id = email_id
        self.inbox_id = inbox_id
        self.user_id = user_id
        self.forwarder_id = forwarder_id
        self.message = message
        self.id = id
        self.status = status

    @property
    def created_at(self):
        """Gets the created_at of this InboxForwarderEventProjection.  # noqa: E501


        :return: The created_at of this InboxForwarderEventProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this InboxForwarderEventProjection.


        :param created_at: The created_at of this InboxForwarderEventProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def email_id(self):
        """Gets the email_id of this InboxForwarderEventProjection.  # noqa: E501


        :return: The email_id of this InboxForwarderEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._email_id

    @email_id.setter
    def email_id(self, email_id):
        """Sets the email_id of this InboxForwarderEventProjection.


        :param email_id: The email_id of this InboxForwarderEventProjection.  # noqa: E501
        :type: str
        """

        self._email_id = email_id

    @property
    def inbox_id(self):
        """Gets the inbox_id of this InboxForwarderEventProjection.  # noqa: E501


        :return: The inbox_id of this InboxForwarderEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this InboxForwarderEventProjection.


        :param inbox_id: The inbox_id of this InboxForwarderEventProjection.  # noqa: E501
        :type: str
        """

        self._inbox_id = inbox_id

    @property
    def user_id(self):
        """Gets the user_id of this InboxForwarderEventProjection.  # noqa: E501


        :return: The user_id of this InboxForwarderEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this InboxForwarderEventProjection.


        :param user_id: The user_id of this InboxForwarderEventProjection.  # noqa: E501
        :type: str
        """

        self._user_id = user_id

    @property
    def forwarder_id(self):
        """Gets the forwarder_id of this InboxForwarderEventProjection.  # noqa: E501


        :return: The forwarder_id of this InboxForwarderEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._forwarder_id

    @forwarder_id.setter
    def forwarder_id(self, forwarder_id):
        """Sets the forwarder_id of this InboxForwarderEventProjection.


        :param forwarder_id: The forwarder_id of this InboxForwarderEventProjection.  # noqa: E501
        :type: str
        """

        self._forwarder_id = forwarder_id

    @property
    def message(self):
        """Gets the message of this InboxForwarderEventProjection.  # noqa: E501


        :return: The message of this InboxForwarderEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this InboxForwarderEventProjection.


        :param message: The message of this InboxForwarderEventProjection.  # noqa: E501
        :type: str
        """

        self._message = message

    @property
    def id(self):
        """Gets the id of this InboxForwarderEventProjection.  # noqa: E501


        :return: The id of this InboxForwarderEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this InboxForwarderEventProjection.


        :param id: The id of this InboxForwarderEventProjection.  # noqa: E501
        :type: str
        """

        self._id = id

    @property
    def status(self):
        """Gets the status of this InboxForwarderEventProjection.  # noqa: E501


        :return: The status of this InboxForwarderEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._status

    @status.setter
    def status(self, status):
        """Sets the status of this InboxForwarderEventProjection.


        :param status: The status of this InboxForwarderEventProjection.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"SUCCESS", "FAILURE"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and status not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `status` ({0}), must be one of {1}"  # noqa: E501
                .format(status, allowed_values)
            )

        self._status = status

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxForwarderEventProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxForwarderEventProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_forwarder_event_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxForwarderEventDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'inbox_id': 'str',
        'email_id': 'str',
        'user_id': 'str',
        'forwarder_id': 'str',
        'message': 'str',
        'status': 'str',
        'created_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'inbox_id': 'inboxId',
        'email_id': 'emailId',
        'user_id': 'userId',
        'forwarder_id': 'forwarderId',
        'message': 'message',
        'status': 'status',
        'created_at': 'createdAt'
    }

    def __init__(self, id=None, inbox_id=None, email_id=None, user_id=None, forwarder_id=None, message=None, status=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """InboxForwarderEventDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._inbox_id = None
        self._email_id = None
        self._user_id = None
        self._forwarder_id = None
        self._message = None
        self._status = None
        self._created_at = None
        self.discriminator = None

        self.id = id
        self.inbox_id = inbox_id
        self.email_id = email_id
        self.user_id = user_id
        self.forwarder_id = forwarder_id
        self.message = message
        self.status = status
        self.created_at = created_at

    @property
    def id(self):
        """Gets the id of this InboxForwarderEventDto.  # noqa: E501


        :return: The id of this InboxForwarderEventDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this InboxForwarderEventDto.


        :param id: The id of this InboxForwarderEventDto.  # noqa: E501
        :type: str
        """

        self._id = id

    @property
    def inbox_id(self):
        """Gets the inbox_id of this InboxForwarderEventDto.  # noqa: E501


        :return: The inbox_id of this InboxForwarderEventDto.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this InboxForwarderEventDto.


        :param inbox_id: The inbox_id of this InboxForwarderEventDto.  # noqa: E501
        :type: str
        """

        self._inbox_id = inbox_id

    @property
    def email_id(self):
        """Gets the email_id of this InboxForwarderEventDto.  # noqa: E501


        :return: The email_id of this InboxForwarderEventDto.  # noqa: E501
        :rtype: str
        """
        return self._email_id

    @email_id.setter
    def email_id(self, email_id):
        """Sets the email_id of this InboxForwarderEventDto.


        :param email_id: The email_id of this InboxForwarderEventDto.  # noqa: E501
        :type: str
        """

        self._email_id = email_id

    @property
    def user_id(self):
        """Gets the user_id of this InboxForwarderEventDto.  # noqa: E501


        :return: The user_id of this InboxForwarderEventDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this InboxForwarderEventDto.


        :param user_id: The user_id of this InboxForwarderEventDto.  # noqa: E501
        :type: str
        """

        self._user_id = user_id

    @property
    def forwarder_id(self):
        """Gets the forwarder_id of this InboxForwarderEventDto.  # noqa: E501


        :return: The forwarder_id of this InboxForwarderEventDto.  # noqa: E501
        :rtype: str
        """
        return self._forwarder_id

    @forwarder_id.setter
    def forwarder_id(self, forwarder_id):
        """Sets the forwarder_id of this InboxForwarderEventDto.


        :param forwarder_id: The forwarder_id of this InboxForwarderEventDto.  # noqa: E501
        :type: str
        """

        self._forwarder_id = forwarder_id

    @property
    def message(self):
        """Gets the message of this InboxForwarderEventDto.  # noqa: E501


        :return: The message of this InboxForwarderEventDto.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this InboxForwarderEventDto.


        :param message: The message of this InboxForwarderEventDto.  # noqa: E501
        :type: str
        """

        self._message = message

    @property
    def status(self):
        """Gets the status of this InboxForwarderEventDto.  # noqa: E501


        :return: The status of this InboxForwarderEventDto.  # noqa: E501
        :rtype: str
        """
        return self._status

    @status.setter
    def status(self, status):
        """Sets the status of this InboxForwarderEventDto.


        :param status: The status of this InboxForwarderEventDto.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"SUCCESS", "FAILURE"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and status not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `status` ({0}), must be one of {1}"  # noqa: E501
                .format(status, allowed_values)
            )

        self._status = status

    @property
    def created_at(self):
        """Gets the created_at of this InboxForwarderEventDto.  # noqa: E501


        :return: The created_at of this InboxForwarderEventDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this InboxForwarderEventDto.


        :param created_at: The created_at of this InboxForwarderEventDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxForwarderEventDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxForwarderEventDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_forwarder_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxForwarderDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'inbox_id': 'str',
        'name': 'str',
        'field': 'str',
        'match': 'str',
        'forward_to_recipients': 'list[str]',
        'created_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'inbox_id': 'inboxId',
        'name': 'name',
        'field': 'field',
        'match': 'match',
        'forward_to_recipients': 'forwardToRecipients',
        'created_at': 'createdAt'
    }

    def __init__(self, id=None, inbox_id=None, name=None, field=None, match=None, forward_to_recipients=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """InboxForwarderDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._inbox_id = None
        self._name = None
        self._field = None
        self._match = None
        self._forward_to_recipients = None
        self._created_at = None
        self.discriminator = None

        self.id = id
        self.inbox_id = inbox_id
        self.name = name
        self.field = field
        self.match = match
        self.forward_to_recipients = forward_to_recipients
        self.created_at = created_at

    @property
    def id(self):
        """Gets the id of this InboxForwarderDto.  # noqa: E501


        :return: The id of this InboxForwarderDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this InboxForwarderDto.


        :param id: The id of this InboxForwarderDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def inbox_id(self):
        """Gets the inbox_id of this InboxForwarderDto.  # noqa: E501


        :return: The inbox_id of this InboxForwarderDto.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this InboxForwarderDto.


        :param inbox_id: The inbox_id of this InboxForwarderDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def name(self):
        """Gets the name of this InboxForwarderDto.  # noqa: E501

        Name of inbox forwarder  # noqa: E501

        :return: The name of this InboxForwarderDto.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this InboxForwarderDto.

        Name of inbox forwarder  # noqa: E501

        :param name: The name of this InboxForwarderDto.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def field(self):
        """Gets the field of this InboxForwarderDto.  # noqa: E501

        Which field to match against  # noqa: E501

        :return: The field of this InboxForwarderDto.  # noqa: E501
        :rtype: str
        """
        return self._field

    @field.setter
    def field(self, field):
        """Sets the field of this InboxForwarderDto.

        Which field to match against  # noqa: E501

        :param field: The field of this InboxForwarderDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and field is None:  # noqa: E501
            raise ValueError("Invalid value for `field`, must not be `None`")  # noqa: E501
        allowed_values = ["RECIPIENTS", "SENDER", "SUBJECT", "ATTACHMENTS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and field not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `field` ({0}), must be one of {1}"  # noqa: E501
                .format(field, allowed_values)
            )

        self._field = field

    @property
    def match(self):
        """Gets the match of this InboxForwarderDto.  # noqa: E501

        Wild-card type pattern to apply to field  # noqa: E501

        :return: The match of this InboxForwarderDto.  # noqa: E501
        :rtype: str
        """
        return self._match

    @match.setter
    def match(self, match):
        """Sets the match of this InboxForwarderDto.

        Wild-card type pattern to apply to field  # noqa: E501

        :param match: The match of this InboxForwarderDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and match is None:  # noqa: E501
            raise ValueError("Invalid value for `match`, must not be `None`")  # noqa: E501

        self._match = match

    @property
    def forward_to_recipients(self):
        """Gets the forward_to_recipients of this InboxForwarderDto.  # noqa: E501

        Who to send forwarded email to  # noqa: E501

        :return: The forward_to_recipients of this InboxForwarderDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._forward_to_recipients

    @forward_to_recipients.setter
    def forward_to_recipients(self, forward_to_recipients):
        """Sets the forward_to_recipients of this InboxForwarderDto.

        Who to send forwarded email to  # noqa: E501

        :param forward_to_recipients: The forward_to_recipients of this InboxForwarderDto.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and forward_to_recipients is None:  # noqa: E501
            raise ValueError("Invalid value for `forward_to_recipients`, must not be `None`")  # noqa: E501

        self._forward_to_recipients = forward_to_recipients

    @property
    def created_at(self):
        """Gets the created_at of this InboxForwarderDto.  # noqa: E501


        :return: The created_at of this InboxForwarderDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this InboxForwarderDto.


        :param created_at: The created_at of this InboxForwarderDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxForwarderDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxForwarderDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_exists_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxExistsDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'exists': 'bool'
    }

    attribute_map = {
        'exists': 'exists'
    }

    def __init__(self, exists=None, local_vars_configuration=None):  # noqa: E501
        """InboxExistsDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._exists = None
        self.discriminator = None

        self.exists = exists

    @property
    def exists(self):
        """Gets the exists of this InboxExistsDto.  # noqa: E501


        :return: The exists of this InboxExistsDto.  # noqa: E501
        :rtype: bool
        """
        return self._exists

    @exists.setter
    def exists(self, exists):
        """Sets the exists of this InboxExistsDto.


        :param exists: The exists of this InboxExistsDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and exists is None:  # noqa: E501
            raise ValueError("Invalid value for `exists`, must not be `None`")  # noqa: E501

        self._exists = exists

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxExistsDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxExistsDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'created_at': 'datetime',
        'name': 'str',
        'domain_id': 'str',
        'description': 'str',
        'email_address': 'str',
        'expires_at': 'str',
        'favourite': 'bool',
        'tags': 'list[str]',
        'inbox_type': 'str',
        'read_only': 'bool',
        'virtual_inbox': 'bool',
        'functions_as': 'str'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'created_at': 'createdAt',
        'name': 'name',
        'domain_id': 'domainId',
        'description': 'description',
        'email_address': 'emailAddress',
        'expires_at': 'expiresAt',
        'favourite': 'favourite',
        'tags': 'tags',
        'inbox_type': 'inboxType',
        'read_only': 'readOnly',
        'virtual_inbox': 'virtualInbox',
        'functions_as': 'functionsAs'
    }

    def __init__(self, id=None, user_id=None, created_at=None, name=None, domain_id=None, description=None, email_address=None, expires_at=None, favourite=None, tags=None, inbox_type=None, read_only=None, virtual_inbox=None, functions_as=None, local_vars_configuration=None):  # noqa: E501
        """InboxDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._created_at = None
        self._name = None
        self._domain_id = None
        self._description = None
        self._email_address = None
        self._expires_at = None
        self._favourite = None
        self._tags = None
        self._inbox_type = None
        self._read_only = None
        self._virtual_inbox = None
        self._functions_as = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        self.created_at = created_at
        self.name = name
        self.domain_id = domain_id
        self.description = description
        self.email_address = email_address
        self.expires_at = expires_at
        self.favourite = favourite
        self.tags = tags
        self.inbox_type = inbox_type
        self.read_only = read_only
        self.virtual_inbox = virtual_inbox
        self.functions_as = functions_as

    @property
    def id(self):
        """Gets the id of this InboxDto.  # noqa: E501

        ID of the inbox. The ID is a UUID-V4 format string. Use the inboxId for calls to Inbox and Email Controller endpoints. See the emailAddress property for the email address or the inbox. To get emails in an inbox use the WaitFor and Inbox Controller methods `waitForLatestEmail` and `getEmails` methods respectively. Inboxes can be used with aliases to forward emails automatically.  # noqa: E501

        :return: The id of this InboxDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this InboxDto.

        ID of the inbox. The ID is a UUID-V4 format string. Use the inboxId for calls to Inbox and Email Controller endpoints. See the emailAddress property for the email address or the inbox. To get emails in an inbox use the WaitFor and Inbox Controller methods `waitForLatestEmail` and `getEmails` methods respectively. Inboxes can be used with aliases to forward emails automatically.  # noqa: E501

        :param id: The id of this InboxDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this InboxDto.  # noqa: E501

        ID of user that inbox belongs to  # noqa: E501

        :return: The user_id of this InboxDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this InboxDto.

        ID of user that inbox belongs to  # noqa: E501

        :param user_id: The user_id of this InboxDto.  # noqa: E501
        :type: str
        """

        self._user_id = user_id

    @property
    def created_at(self):
        """Gets the created_at of this InboxDto.  # noqa: E501

        When the inbox was created. Time stamps are in ISO DateTime Format `yyyy-MM-dd'T'HH:mm:ss.SSSXXX` e.g. `2000-10-31T01:30:00.000-05:00`.  # noqa: E501

        :return: The created_at of this InboxDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this InboxDto.

        When the inbox was created. Time stamps are in ISO DateTime Format `yyyy-MM-dd'T'HH:mm:ss.SSSXXX` e.g. `2000-10-31T01:30:00.000-05:00`.  # noqa: E501

        :param created_at: The created_at of this InboxDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def name(self):
        """Gets the name of this InboxDto.  # noqa: E501

        Name of the inbox and used as the sender name when sending emails .Displayed in the dashboard for easier search  # noqa: E501

        :return: The name of this InboxDto.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this InboxDto.

        Name of the inbox and used as the sender name when sending emails .Displayed in the dashboard for easier search  # noqa: E501

        :param name: The name of this InboxDto.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def domain_id(self):
        """Gets the domain_id of this InboxDto.  # noqa: E501

        ID of custom domain used by the inbox if any  # noqa: E501

        :return: The domain_id of this InboxDto.  # noqa: E501
        :rtype: str
        """
        return self._domain_id

    @domain_id.setter
    def domain_id(self, domain_id):
        """Sets the domain_id of this InboxDto.

        ID of custom domain used by the inbox if any  # noqa: E501

        :param domain_id: The domain_id of this InboxDto.  # noqa: E501
        :type: str
        """

        self._domain_id = domain_id

    @property
    def description(self):
        """Gets the description of this InboxDto.  # noqa: E501

        Description of an inbox for labelling and searching purposes  # noqa: E501

        :return: The description of this InboxDto.  # noqa: E501
        :rtype: str
        """
        return self._description

    @description.setter
    def description(self, description):
        """Sets the description of this InboxDto.

        Description of an inbox for labelling and searching purposes  # noqa: E501

        :param description: The description of this InboxDto.  # noqa: E501
        :type: str
        """

        self._description = description

    @property
    def email_address(self):
        """Gets the email_address of this InboxDto.  # noqa: E501

        The inbox's email address. Inbox projections and previews may not include the email address. To view the email address fetch the inbox entity directly. Send an email to this address and the inbox will receive and store it for you. Note the email address in MailSlurp match characters exactly and are case sensitive so `+123` additions are considered different addresses. To retrieve the email use the Inbox and Email Controller endpoints with the inbox ID.  # noqa: E501

        :return: The email_address of this InboxDto.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this InboxDto.

        The inbox's email address. Inbox projections and previews may not include the email address. To view the email address fetch the inbox entity directly. Send an email to this address and the inbox will receive and store it for you. Note the email address in MailSlurp match characters exactly and are case sensitive so `+123` additions are considered different addresses. To retrieve the email use the Inbox and Email Controller endpoints with the inbox ID.  # noqa: E501

        :param email_address: The email_address of this InboxDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    @property
    def expires_at(self):
        """Gets the expires_at of this InboxDto.  # noqa: E501

        Inbox expiration time. When, if ever, the inbox should expire and be deleted. If null then this inbox is permanent and the emails in it won't be deleted. This is the default behavior unless expiration date is set. If an expiration date is set and the time is reached MailSlurp will expire the inbox and move it to an expired inbox entity. You can still access the emails belonging to it but it can no longer send or receive email.  # noqa: E501

        :return: The expires_at of this InboxDto.  # noqa: E501
        :rtype: str
        """
        return self._expires_at

    @expires_at.setter
    def expires_at(self, expires_at):
        """Sets the expires_at of this InboxDto.

        Inbox expiration time. When, if ever, the inbox should expire and be deleted. If null then this inbox is permanent and the emails in it won't be deleted. This is the default behavior unless expiration date is set. If an expiration date is set and the time is reached MailSlurp will expire the inbox and move it to an expired inbox entity. You can still access the emails belonging to it but it can no longer send or receive email.  # noqa: E501

        :param expires_at: The expires_at of this InboxDto.  # noqa: E501
        :type: str
        """

        self._expires_at = expires_at

    @property
    def favourite(self):
        """Gets the favourite of this InboxDto.  # noqa: E501

        Is the inbox a favorite inbox. Make an inbox a favorite is typically done in the dashboard for quick access or filtering  # noqa: E501

        :return: The favourite of this InboxDto.  # noqa: E501
        :rtype: bool
        """
        return self._favourite

    @favourite.setter
    def favourite(self, favourite):
        """Sets the favourite of this InboxDto.

        Is the inbox a favorite inbox. Make an inbox a favorite is typically done in the dashboard for quick access or filtering  # noqa: E501

        :param favourite: The favourite of this InboxDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and favourite is None:  # noqa: E501
            raise ValueError("Invalid value for `favourite`, must not be `None`")  # noqa: E501

        self._favourite = favourite

    @property
    def tags(self):
        """Gets the tags of this InboxDto.  # noqa: E501

        Tags that inbox has been tagged with. Tags can be added to inboxes to group different inboxes within an account. You can also search for inboxes by tag in the dashboard UI.  # noqa: E501

        :return: The tags of this InboxDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._tags

    @tags.setter
    def tags(self, tags):
        """Sets the tags of this InboxDto.

        Tags that inbox has been tagged with. Tags can be added to inboxes to group different inboxes within an account. You can also search for inboxes by tag in the dashboard UI.  # noqa: E501

        :param tags: The tags of this InboxDto.  # noqa: E501
        :type: list[str]
        """

        self._tags = tags

    @property
    def inbox_type(self):
        """Gets the inbox_type of this InboxDto.  # noqa: E501

        Type of inbox. HTTP inboxes are faster and better for most cases. SMTP inboxes are more suited for public facing inbound messages (but cannot send).  # noqa: E501

        :return: The inbox_type of this InboxDto.  # noqa: E501
        :rtype: str
        """
        return self._inbox_type

    @inbox_type.setter
    def inbox_type(self, inbox_type):
        """Sets the inbox_type of this InboxDto.

        Type of inbox. HTTP inboxes are faster and better for most cases. SMTP inboxes are more suited for public facing inbound messages (but cannot send).  # noqa: E501

        :param inbox_type: The inbox_type of this InboxDto.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"HTTP_INBOX", "SMTP_INBOX"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and inbox_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `inbox_type` ({0}), must be one of {1}"  # noqa: E501
                .format(inbox_type, allowed_values)
            )

        self._inbox_type = inbox_type

    @property
    def read_only(self):
        """Gets the read_only of this InboxDto.  # noqa: E501

        Is the inbox readOnly for the caller. Read only means can not be deleted or modified. This flag is present when using team accounts and shared inboxes.  # noqa: E501

        :return: The read_only of this InboxDto.  # noqa: E501
        :rtype: bool
        """
        return self._read_only

    @read_only.setter
    def read_only(self, read_only):
        """Sets the read_only of this InboxDto.

        Is the inbox readOnly for the caller. Read only means can not be deleted or modified. This flag is present when using team accounts and shared inboxes.  # noqa: E501

        :param read_only: The read_only of this InboxDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and read_only is None:  # noqa: E501
            raise ValueError("Invalid value for `read_only`, must not be `None`")  # noqa: E501

        self._read_only = read_only

    @property
    def virtual_inbox(self):
        """Gets the virtual_inbox of this InboxDto.  # noqa: E501

        Virtual inbox can receive email but will not send emails to real recipients. Will save sent email record but never send an actual email. Perfect for testing mail server actions.  # noqa: E501

        :return: The virtual_inbox of this InboxDto.  # noqa: E501
        :rtype: bool
        """
        return self._virtual_inbox

    @virtual_inbox.setter
    def virtual_inbox(self, virtual_inbox):
        """Sets the virtual_inbox of this InboxDto.

        Virtual inbox can receive email but will not send emails to real recipients. Will save sent email record but never send an actual email. Perfect for testing mail server actions.  # noqa: E501

        :param virtual_inbox: The virtual_inbox of this InboxDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and virtual_inbox is None:  # noqa: E501
            raise ValueError("Invalid value for `virtual_inbox`, must not be `None`")  # noqa: E501

        self._virtual_inbox = virtual_inbox

    @property
    def functions_as(self):
        """Gets the functions_as of this InboxDto.  # noqa: E501

        Inbox function if used as a primitive for another system.  # noqa: E501

        :return: The functions_as of this InboxDto.  # noqa: E501
        :rtype: str
        """
        return self._functions_as

    @functions_as.setter
    def functions_as(self, functions_as):
        """Sets the functions_as of this InboxDto.

        Inbox function if used as a primitive for another system.  # noqa: E501

        :param functions_as: The functions_as of this InboxDto.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"ALIAS", "THREAD", "CATCH_ALL", "CONNECTOR"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and functions_as not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `functions_as` ({0}), must be one of {1}"  # noqa: E501
                .format(functions_as, allowed_values)
            )

        self._functions_as = functions_as

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_by_name_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxByNameResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'inbox_id': 'str',
        'exists': 'bool'
    }

    attribute_map = {
        'inbox_id': 'inboxId',
        'exists': 'exists'
    }

    def __init__(self, inbox_id=None, exists=None, local_vars_configuration=None):  # noqa: E501
        """InboxByNameResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._inbox_id = None
        self._exists = None
        self.discriminator = None

        self.inbox_id = inbox_id
        self.exists = exists

    @property
    def inbox_id(self):
        """Gets the inbox_id of this InboxByNameResult.  # noqa: E501


        :return: The inbox_id of this InboxByNameResult.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this InboxByNameResult.


        :param inbox_id: The inbox_id of this InboxByNameResult.  # noqa: E501
        :type: str
        """

        self._inbox_id = inbox_id

    @property
    def exists(self):
        """Gets the exists of this InboxByNameResult.  # noqa: E501


        :return: The exists of this InboxByNameResult.  # noqa: E501
        :rtype: bool
        """
        return self._exists

    @exists.setter
    def exists(self, exists):
        """Sets the exists of this InboxByNameResult.


        :param exists: The exists of this InboxByNameResult.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and exists is None:  # noqa: E501
            raise ValueError("Invalid value for `exists`, must not be `None`")  # noqa: E501

        self._exists = exists

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxByNameResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxByNameResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/inbox_by_email_address_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class InboxByEmailAddressResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'inbox_id': 'str',
        'exists': 'bool'
    }

    attribute_map = {
        'inbox_id': 'inboxId',
        'exists': 'exists'
    }

    def __init__(self, inbox_id=None, exists=None, local_vars_configuration=None):  # noqa: E501
        """InboxByEmailAddressResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._inbox_id = None
        self._exists = None
        self.discriminator = None

        self.inbox_id = inbox_id
        self.exists = exists

    @property
    def inbox_id(self):
        """Gets the inbox_id of this InboxByEmailAddressResult.  # noqa: E501


        :return: The inbox_id of this InboxByEmailAddressResult.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this InboxByEmailAddressResult.


        :param inbox_id: The inbox_id of this InboxByEmailAddressResult.  # noqa: E501
        :type: str
        """

        self._inbox_id = inbox_id

    @property
    def exists(self):
        """Gets the exists of this InboxByEmailAddressResult.  # noqa: E501


        :return: The exists of this InboxByEmailAddressResult.  # noqa: E501
        :rtype: bool
        """
        return self._exists

    @exists.setter
    def exists(self, exists):
        """Sets the exists of this InboxByEmailAddressResult.


        :param exists: The exists of this InboxByEmailAddressResult.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and exists is None:  # noqa: E501
            raise ValueError("Invalid value for `exists`, must not be `None`")  # noqa: E501

        self._exists = exists

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, InboxByEmailAddressResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, InboxByEmailAddressResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_update_flags_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapUpdateFlagsOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'operation': 'str',
        'flags': 'list[str]',
        'uid_set': 'str',
        'seq_set': 'str'
    }

    attribute_map = {
        'operation': 'operation',
        'flags': 'flags',
        'uid_set': 'uidSet',
        'seq_set': 'seqSet'
    }

    def __init__(self, operation=None, flags=None, uid_set=None, seq_set=None, local_vars_configuration=None):  # noqa: E501
        """ImapUpdateFlagsOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._operation = None
        self._flags = None
        self._uid_set = None
        self._seq_set = None
        self.discriminator = None

        self.operation = operation
        self.flags = flags
        self.uid_set = uid_set
        self.seq_set = seq_set

    @property
    def operation(self):
        """Gets the operation of this ImapUpdateFlagsOptions.  # noqa: E501


        :return: The operation of this ImapUpdateFlagsOptions.  # noqa: E501
        :rtype: str
        """
        return self._operation

    @operation.setter
    def operation(self, operation):
        """Sets the operation of this ImapUpdateFlagsOptions.


        :param operation: The operation of this ImapUpdateFlagsOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and operation is None:  # noqa: E501
            raise ValueError("Invalid value for `operation`, must not be `None`")  # noqa: E501

        self._operation = operation

    @property
    def flags(self):
        """Gets the flags of this ImapUpdateFlagsOptions.  # noqa: E501


        :return: The flags of this ImapUpdateFlagsOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._flags

    @flags.setter
    def flags(self, flags):
        """Sets the flags of this ImapUpdateFlagsOptions.


        :param flags: The flags of this ImapUpdateFlagsOptions.  # noqa: E501
        :type: list[str]
        """

        self._flags = flags

    @property
    def uid_set(self):
        """Gets the uid_set of this ImapUpdateFlagsOptions.  # noqa: E501


        :return: The uid_set of this ImapUpdateFlagsOptions.  # noqa: E501
        :rtype: str
        """
        return self._uid_set

    @uid_set.setter
    def uid_set(self, uid_set):
        """Sets the uid_set of this ImapUpdateFlagsOptions.


        :param uid_set: The uid_set of this ImapUpdateFlagsOptions.  # noqa: E501
        :type: str
        """

        self._uid_set = uid_set

    @property
    def seq_set(self):
        """Gets the seq_set of this ImapUpdateFlagsOptions.  # noqa: E501


        :return: The seq_set of this ImapUpdateFlagsOptions.  # noqa: E501
        :rtype: str
        """
        return self._seq_set

    @seq_set.setter
    def seq_set(self, seq_set):
        """Sets the seq_set of this ImapUpdateFlagsOptions.


        :param seq_set: The seq_set of this ImapUpdateFlagsOptions.  # noqa: E501
        :type: str
        """

        self._seq_set = seq_set

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapUpdateFlagsOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapUpdateFlagsOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_smtp_access_servers.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapSmtpAccessServers(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'imap_server': 'ServerEndpoints',
        'secure_imap_server': 'ServerEndpoints',
        'smtp_server': 'ServerEndpoints',
        'secure_smtp_server': 'ServerEndpoints'
    }

    attribute_map = {
        'imap_server': 'imapServer',
        'secure_imap_server': 'secureImapServer',
        'smtp_server': 'smtpServer',
        'secure_smtp_server': 'secureSmtpServer'
    }

    def __init__(self, imap_server=None, secure_imap_server=None, smtp_server=None, secure_smtp_server=None, local_vars_configuration=None):  # noqa: E501
        """ImapSmtpAccessServers - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._imap_server = None
        self._secure_imap_server = None
        self._smtp_server = None
        self._secure_smtp_server = None
        self.discriminator = None

        self.imap_server = imap_server
        self.secure_imap_server = secure_imap_server
        self.smtp_server = smtp_server
        self.secure_smtp_server = secure_smtp_server

    @property
    def imap_server(self):
        """Gets the imap_server of this ImapSmtpAccessServers.  # noqa: E501


        :return: The imap_server of this ImapSmtpAccessServers.  # noqa: E501
        :rtype: ServerEndpoints
        """
        return self._imap_server

    @imap_server.setter
    def imap_server(self, imap_server):
        """Sets the imap_server of this ImapSmtpAccessServers.


        :param imap_server: The imap_server of this ImapSmtpAccessServers.  # noqa: E501
        :type: ServerEndpoints
        """
        if self.local_vars_configuration.client_side_validation and imap_server is None:  # noqa: E501
            raise ValueError("Invalid value for `imap_server`, must not be `None`")  # noqa: E501

        self._imap_server = imap_server

    @property
    def secure_imap_server(self):
        """Gets the secure_imap_server of this ImapSmtpAccessServers.  # noqa: E501


        :return: The secure_imap_server of this ImapSmtpAccessServers.  # noqa: E501
        :rtype: ServerEndpoints
        """
        return self._secure_imap_server

    @secure_imap_server.setter
    def secure_imap_server(self, secure_imap_server):
        """Sets the secure_imap_server of this ImapSmtpAccessServers.


        :param secure_imap_server: The secure_imap_server of this ImapSmtpAccessServers.  # noqa: E501
        :type: ServerEndpoints
        """
        if self.local_vars_configuration.client_side_validation and secure_imap_server is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_imap_server`, must not be `None`")  # noqa: E501

        self._secure_imap_server = secure_imap_server

    @property
    def smtp_server(self):
        """Gets the smtp_server of this ImapSmtpAccessServers.  # noqa: E501


        :return: The smtp_server of this ImapSmtpAccessServers.  # noqa: E501
        :rtype: ServerEndpoints
        """
        return self._smtp_server

    @smtp_server.setter
    def smtp_server(self, smtp_server):
        """Sets the smtp_server of this ImapSmtpAccessServers.


        :param smtp_server: The smtp_server of this ImapSmtpAccessServers.  # noqa: E501
        :type: ServerEndpoints
        """
        if self.local_vars_configuration.client_side_validation and smtp_server is None:  # noqa: E501
            raise ValueError("Invalid value for `smtp_server`, must not be `None`")  # noqa: E501

        self._smtp_server = smtp_server

    @property
    def secure_smtp_server(self):
        """Gets the secure_smtp_server of this ImapSmtpAccessServers.  # noqa: E501


        :return: The secure_smtp_server of this ImapSmtpAccessServers.  # noqa: E501
        :rtype: ServerEndpoints
        """
        return self._secure_smtp_server

    @secure_smtp_server.setter
    def secure_smtp_server(self, secure_smtp_server):
        """Sets the secure_smtp_server of this ImapSmtpAccessServers.


        :param secure_smtp_server: The secure_smtp_server of this ImapSmtpAccessServers.  # noqa: E501
        :type: ServerEndpoints
        """
        if self.local_vars_configuration.client_side_validation and secure_smtp_server is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_smtp_server`, must not be `None`")  # noqa: E501

        self._secure_smtp_server = secure_smtp_server

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapSmtpAccessServers):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapSmtpAccessServers):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_smtp_access_details.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapSmtpAccessDetails(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'secure_smtp_server_host': 'str',
        'secure_smtp_server_port': 'int',
        'secure_smtp_username': 'str',
        'secure_smtp_password': 'str',
        'smtp_server_host': 'str',
        'smtp_server_port': 'int',
        'smtp_username': 'str',
        'smtp_password': 'str',
        'secure_imap_server_host': 'str',
        'secure_imap_server_port': 'int',
        'secure_imap_username': 'str',
        'secure_imap_password': 'str',
        'imap_server_host': 'str',
        'imap_server_port': 'int',
        'imap_username': 'str',
        'imap_password': 'str',
        'imap_mailbox': 'str',
        'mail_from_domain': 'str'
    }

    attribute_map = {
        'secure_smtp_server_host': 'secureSmtpServerHost',
        'secure_smtp_server_port': 'secureSmtpServerPort',
        'secure_smtp_username': 'secureSmtpUsername',
        'secure_smtp_password': 'secureSmtpPassword',
        'smtp_server_host': 'smtpServerHost',
        'smtp_server_port': 'smtpServerPort',
        'smtp_username': 'smtpUsername',
        'smtp_password': 'smtpPassword',
        'secure_imap_server_host': 'secureImapServerHost',
        'secure_imap_server_port': 'secureImapServerPort',
        'secure_imap_username': 'secureImapUsername',
        'secure_imap_password': 'secureImapPassword',
        'imap_server_host': 'imapServerHost',
        'imap_server_port': 'imapServerPort',
        'imap_username': 'imapUsername',
        'imap_password': 'imapPassword',
        'imap_mailbox': 'imapMailbox',
        'mail_from_domain': 'mailFromDomain'
    }

    def __init__(self, secure_smtp_server_host=None, secure_smtp_server_port=None, secure_smtp_username=None, secure_smtp_password=None, smtp_server_host=None, smtp_server_port=None, smtp_username=None, smtp_password=None, secure_imap_server_host=None, secure_imap_server_port=None, secure_imap_username=None, secure_imap_password=None, imap_server_host=None, imap_server_port=None, imap_username=None, imap_password=None, imap_mailbox=None, mail_from_domain=None, local_vars_configuration=None):  # noqa: E501
        """ImapSmtpAccessDetails - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._secure_smtp_server_host = None
        self._secure_smtp_server_port = None
        self._secure_smtp_username = None
        self._secure_smtp_password = None
        self._smtp_server_host = None
        self._smtp_server_port = None
        self._smtp_username = None
        self._smtp_password = None
        self._secure_imap_server_host = None
        self._secure_imap_server_port = None
        self._secure_imap_username = None
        self._secure_imap_password = None
        self._imap_server_host = None
        self._imap_server_port = None
        self._imap_username = None
        self._imap_password = None
        self._imap_mailbox = None
        self._mail_from_domain = None
        self.discriminator = None

        self.secure_smtp_server_host = secure_smtp_server_host
        self.secure_smtp_server_port = secure_smtp_server_port
        self.secure_smtp_username = secure_smtp_username
        self.secure_smtp_password = secure_smtp_password
        self.smtp_server_host = smtp_server_host
        self.smtp_server_port = smtp_server_port
        self.smtp_username = smtp_username
        self.smtp_password = smtp_password
        self.secure_imap_server_host = secure_imap_server_host
        self.secure_imap_server_port = secure_imap_server_port
        self.secure_imap_username = secure_imap_username
        self.secure_imap_password = secure_imap_password
        self.imap_server_host = imap_server_host
        self.imap_server_port = imap_server_port
        self.imap_username = imap_username
        self.imap_password = imap_password
        self.imap_mailbox = imap_mailbox
        self.mail_from_domain = mail_from_domain

    @property
    def secure_smtp_server_host(self):
        """Gets the secure_smtp_server_host of this ImapSmtpAccessDetails.  # noqa: E501

        Secure TLS SMTP server host domain  # noqa: E501

        :return: The secure_smtp_server_host of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._secure_smtp_server_host

    @secure_smtp_server_host.setter
    def secure_smtp_server_host(self, secure_smtp_server_host):
        """Sets the secure_smtp_server_host of this ImapSmtpAccessDetails.

        Secure TLS SMTP server host domain  # noqa: E501

        :param secure_smtp_server_host: The secure_smtp_server_host of this ImapSmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and secure_smtp_server_host is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_smtp_server_host`, must not be `None`")  # noqa: E501

        self._secure_smtp_server_host = secure_smtp_server_host

    @property
    def secure_smtp_server_port(self):
        """Gets the secure_smtp_server_port of this ImapSmtpAccessDetails.  # noqa: E501

        Secure TLS SMTP server host port  # noqa: E501

        :return: The secure_smtp_server_port of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: int
        """
        return self._secure_smtp_server_port

    @secure_smtp_server_port.setter
    def secure_smtp_server_port(self, secure_smtp_server_port):
        """Sets the secure_smtp_server_port of this ImapSmtpAccessDetails.

        Secure TLS SMTP server host port  # noqa: E501

        :param secure_smtp_server_port: The secure_smtp_server_port of this ImapSmtpAccessDetails.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and secure_smtp_server_port is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_smtp_server_port`, must not be `None`")  # noqa: E501

        self._secure_smtp_server_port = secure_smtp_server_port

    @property
    def secure_smtp_username(self):
        """Gets the secure_smtp_username of this ImapSmtpAccessDetails.  # noqa: E501

        Secure TLS SMTP username for login  # noqa: E501

        :return: The secure_smtp_username of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._secure_smtp_username

    @secure_smtp_username.setter
    def secure_smtp_username(self, secure_smtp_username):
        """Sets the secure_smtp_username of this ImapSmtpAccessDetails.

        Secure TLS SMTP username for login  # noqa: E501

        :param secure_smtp_username: The secure_smtp_username of this ImapSmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and secure_smtp_username is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_smtp_username`, must not be `None`")  # noqa: E501

        self._secure_smtp_username = secure_smtp_username

    @property
    def secure_smtp_password(self):
        """Gets the secure_smtp_password of this ImapSmtpAccessDetails.  # noqa: E501

        Secure TLS SMTP password for login  # noqa: E501

        :return: The secure_smtp_password of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._secure_smtp_password

    @secure_smtp_password.setter
    def secure_smtp_password(self, secure_smtp_password):
        """Sets the secure_smtp_password of this ImapSmtpAccessDetails.

        Secure TLS SMTP password for login  # noqa: E501

        :param secure_smtp_password: The secure_smtp_password of this ImapSmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and secure_smtp_password is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_smtp_password`, must not be `None`")  # noqa: E501

        self._secure_smtp_password = secure_smtp_password

    @property
    def smtp_server_host(self):
        """Gets the smtp_server_host of this ImapSmtpAccessDetails.  # noqa: E501

        SMTP server host domain  # noqa: E501

        :return: The smtp_server_host of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._smtp_server_host

    @smtp_server_host.setter
    def smtp_server_host(self, smtp_server_host):
        """Sets the smtp_server_host of this ImapSmtpAccessDetails.

        SMTP server host domain  # noqa: E501

        :param smtp_server_host: The smtp_server_host of this ImapSmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and smtp_server_host is None:  # noqa: E501
            raise ValueError("Invalid value for `smtp_server_host`, must not be `None`")  # noqa: E501

        self._smtp_server_host = smtp_server_host

    @property
    def smtp_server_port(self):
        """Gets the smtp_server_port of this ImapSmtpAccessDetails.  # noqa: E501

        SMTP server host port  # noqa: E501

        :return: The smtp_server_port of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: int
        """
        return self._smtp_server_port

    @smtp_server_port.setter
    def smtp_server_port(self, smtp_server_port):
        """Sets the smtp_server_port of this ImapSmtpAccessDetails.

        SMTP server host port  # noqa: E501

        :param smtp_server_port: The smtp_server_port of this ImapSmtpAccessDetails.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and smtp_server_port is None:  # noqa: E501
            raise ValueError("Invalid value for `smtp_server_port`, must not be `None`")  # noqa: E501

        self._smtp_server_port = smtp_server_port

    @property
    def smtp_username(self):
        """Gets the smtp_username of this ImapSmtpAccessDetails.  # noqa: E501

        SMTP username for login  # noqa: E501

        :return: The smtp_username of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._smtp_username

    @smtp_username.setter
    def smtp_username(self, smtp_username):
        """Sets the smtp_username of this ImapSmtpAccessDetails.

        SMTP username for login  # noqa: E501

        :param smtp_username: The smtp_username of this ImapSmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and smtp_username is None:  # noqa: E501
            raise ValueError("Invalid value for `smtp_username`, must not be `None`")  # noqa: E501

        self._smtp_username = smtp_username

    @property
    def smtp_password(self):
        """Gets the smtp_password of this ImapSmtpAccessDetails.  # noqa: E501

        SMTP password for login  # noqa: E501

        :return: The smtp_password of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._smtp_password

    @smtp_password.setter
    def smtp_password(self, smtp_password):
        """Sets the smtp_password of this ImapSmtpAccessDetails.

        SMTP password for login  # noqa: E501

        :param smtp_password: The smtp_password of this ImapSmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and smtp_password is None:  # noqa: E501
            raise ValueError("Invalid value for `smtp_password`, must not be `None`")  # noqa: E501

        self._smtp_password = smtp_password

    @property
    def secure_imap_server_host(self):
        """Gets the secure_imap_server_host of this ImapSmtpAccessDetails.  # noqa: E501

        Secure TLS IMAP server host domain  # noqa: E501

        :return: The secure_imap_server_host of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._secure_imap_server_host

    @secure_imap_server_host.setter
    def secure_imap_server_host(self, secure_imap_server_host):
        """Sets the secure_imap_server_host of this ImapSmtpAccessDetails.

        Secure TLS IMAP server host domain  # noqa: E501

        :param secure_imap_server_host: The secure_imap_server_host of this ImapSmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and secure_imap_server_host is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_imap_server_host`, must not be `None`")  # noqa: E501

        self._secure_imap_server_host = secure_imap_server_host

    @property
    def secure_imap_server_port(self):
        """Gets the secure_imap_server_port of this ImapSmtpAccessDetails.  # noqa: E501

        Secure TLS IMAP server host port  # noqa: E501

        :return: The secure_imap_server_port of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: int
        """
        return self._secure_imap_server_port

    @secure_imap_server_port.setter
    def secure_imap_server_port(self, secure_imap_server_port):
        """Sets the secure_imap_server_port of this ImapSmtpAccessDetails.

        Secure TLS IMAP server host port  # noqa: E501

        :param secure_imap_server_port: The secure_imap_server_port of this ImapSmtpAccessDetails.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and secure_imap_server_port is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_imap_server_port`, must not be `None`")  # noqa: E501

        self._secure_imap_server_port = secure_imap_server_port

    @property
    def secure_imap_username(self):
        """Gets the secure_imap_username of this ImapSmtpAccessDetails.  # noqa: E501

        Secure TLS IMAP username for login  # noqa: E501

        :return: The secure_imap_username of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._secure_imap_username

    @secure_imap_username.setter
    def secure_imap_username(self, secure_imap_username):
        """Sets the secure_imap_username of this ImapSmtpAccessDetails.

        Secure TLS IMAP username for login  # noqa: E501

        :param secure_imap_username: The secure_imap_username of this ImapSmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and secure_imap_username is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_imap_username`, must not be `None`")  # noqa: E501

        self._secure_imap_username = secure_imap_username

    @property
    def secure_imap_password(self):
        """Gets the secure_imap_password of this ImapSmtpAccessDetails.  # noqa: E501

        Secure TLS IMAP password for login  # noqa: E501

        :return: The secure_imap_password of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._secure_imap_password

    @secure_imap_password.setter
    def secure_imap_password(self, secure_imap_password):
        """Sets the secure_imap_password of this ImapSmtpAccessDetails.

        Secure TLS IMAP password for login  # noqa: E501

        :param secure_imap_password: The secure_imap_password of this ImapSmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and secure_imap_password is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_imap_password`, must not be `None`")  # noqa: E501

        self._secure_imap_password = secure_imap_password

    @property
    def imap_server_host(self):
        """Gets the imap_server_host of this ImapSmtpAccessDetails.  # noqa: E501

        IMAP server host domain  # noqa: E501

        :return: The imap_server_host of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._imap_server_host

    @imap_server_host.setter
    def imap_server_host(self, imap_server_host):
        """Sets the imap_server_host of this ImapSmtpAccessDetails.

        IMAP server host domain  # noqa: E501

        :param imap_server_host: The imap_server_host of this ImapSmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and imap_server_host is None:  # noqa: E501
            raise ValueError("Invalid value for `imap_server_host`, must not be `None`")  # noqa: E501

        self._imap_server_host = imap_server_host

    @property
    def imap_server_port(self):
        """Gets the imap_server_port of this ImapSmtpAccessDetails.  # noqa: E501

        IMAP server host port  # noqa: E501

        :return: The imap_server_port of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: int
        """
        return self._imap_server_port

    @imap_server_port.setter
    def imap_server_port(self, imap_server_port):
        """Sets the imap_server_port of this ImapSmtpAccessDetails.

        IMAP server host port  # noqa: E501

        :param imap_server_port: The imap_server_port of this ImapSmtpAccessDetails.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and imap_server_port is None:  # noqa: E501
            raise ValueError("Invalid value for `imap_server_port`, must not be `None`")  # noqa: E501

        self._imap_server_port = imap_server_port

    @property
    def imap_username(self):
        """Gets the imap_username of this ImapSmtpAccessDetails.  # noqa: E501

        IMAP username for login  # noqa: E501

        :return: The imap_username of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._imap_username

    @imap_username.setter
    def imap_username(self, imap_username):
        """Sets the imap_username of this ImapSmtpAccessDetails.

        IMAP username for login  # noqa: E501

        :param imap_username: The imap_username of this ImapSmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and imap_username is None:  # noqa: E501
            raise ValueError("Invalid value for `imap_username`, must not be `None`")  # noqa: E501

        self._imap_username = imap_username

    @property
    def imap_password(self):
        """Gets the imap_password of this ImapSmtpAccessDetails.  # noqa: E501

        IMAP password for login  # noqa: E501

        :return: The imap_password of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._imap_password

    @imap_password.setter
    def imap_password(self, imap_password):
        """Sets the imap_password of this ImapSmtpAccessDetails.

        IMAP password for login  # noqa: E501

        :param imap_password: The imap_password of this ImapSmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and imap_password is None:  # noqa: E501
            raise ValueError("Invalid value for `imap_password`, must not be `None`")  # noqa: E501

        self._imap_password = imap_password

    @property
    def imap_mailbox(self):
        """Gets the imap_mailbox of this ImapSmtpAccessDetails.  # noqa: E501

        IMAP mailbox to SELECT  # noqa: E501

        :return: The imap_mailbox of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._imap_mailbox

    @imap_mailbox.setter
    def imap_mailbox(self, imap_mailbox):
        """Sets the imap_mailbox of this ImapSmtpAccessDetails.

        IMAP mailbox to SELECT  # noqa: E501

        :param imap_mailbox: The imap_mailbox of this ImapSmtpAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and imap_mailbox is None:  # noqa: E501
            raise ValueError("Invalid value for `imap_mailbox`, must not be `None`")  # noqa: E501

        self._imap_mailbox = imap_mailbox

    @property
    def mail_from_domain(self):
        """Gets the mail_from_domain of this ImapSmtpAccessDetails.  # noqa: E501

        Mail from domain or SMTP HELO value  # noqa: E501

        :return: The mail_from_domain of this ImapSmtpAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._mail_from_domain

    @mail_from_domain.setter
    def mail_from_domain(self, mail_from_domain):
        """Sets the mail_from_domain of this ImapSmtpAccessDetails.

        Mail from domain or SMTP HELO value  # noqa: E501

        :param mail_from_domain: The mail_from_domain of this ImapSmtpAccessDetails.  # noqa: E501
        :type: str
        """

        self._mail_from_domain = mail_from_domain

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapSmtpAccessDetails):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapSmtpAccessDetails):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_server_status_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapServerStatusResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'result': 'ImapMailboxStatus'
    }

    attribute_map = {
        'result': 'result'
    }

    def __init__(self, result=None, local_vars_configuration=None):  # noqa: E501
        """ImapServerStatusResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._result = None
        self.discriminator = None

        self.result = result

    @property
    def result(self):
        """Gets the result of this ImapServerStatusResult.  # noqa: E501


        :return: The result of this ImapServerStatusResult.  # noqa: E501
        :rtype: ImapMailboxStatus
        """
        return self._result

    @result.setter
    def result(self, result):
        """Sets the result of this ImapServerStatusResult.


        :param result: The result of this ImapServerStatusResult.  # noqa: E501
        :type: ImapMailboxStatus
        """

        self._result = result

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapServerStatusResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapServerStatusResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_server_status_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapServerStatusOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'name': 'str',
        'status_items': 'list[str]'
    }

    attribute_map = {
        'name': 'name',
        'status_items': 'statusItems'
    }

    def __init__(self, name=None, status_items=None, local_vars_configuration=None):  # noqa: E501
        """ImapServerStatusOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._name = None
        self._status_items = None
        self.discriminator = None

        self.name = name
        self.status_items = status_items

    @property
    def name(self):
        """Gets the name of this ImapServerStatusOptions.  # noqa: E501


        :return: The name of this ImapServerStatusOptions.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this ImapServerStatusOptions.


        :param name: The name of this ImapServerStatusOptions.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def status_items(self):
        """Gets the status_items of this ImapServerStatusOptions.  # noqa: E501


        :return: The status_items of this ImapServerStatusOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._status_items

    @status_items.setter
    def status_items(self, status_items):
        """Sets the status_items of this ImapServerStatusOptions.


        :param status_items: The status_items of this ImapServerStatusOptions.  # noqa: E501
        :type: list[str]
        """
        allowed_values = [None,"MESSAGES", "RECENT", "UIDNEXT", "UIDVALIDITY", "UNSEEN", "APPENDLIMIT"]  # noqa: E501
        if (self.local_vars_configuration.client_side_validation and
                not set(status_items).issubset(set(allowed_values))):  # noqa: E501
            raise ValueError(
                "Invalid values for `status_items` [{0}], must be a subset of [{1}]"  # noqa: E501
                .format(", ".join(map(str, set(status_items) - set(allowed_values))),  # noqa: E501
                        ", ".join(map(str, allowed_values)))
            )

        self._status_items = status_items

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapServerStatusOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapServerStatusOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_server_search_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapServerSearchResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'results': 'list[ImapEmailProjection]'
    }

    attribute_map = {
        'results': 'results'
    }

    def __init__(self, results=None, local_vars_configuration=None):  # noqa: E501
        """ImapServerSearchResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._results = None
        self.discriminator = None

        self.results = results

    @property
    def results(self):
        """Gets the results of this ImapServerSearchResult.  # noqa: E501


        :return: The results of this ImapServerSearchResult.  # noqa: E501
        :rtype: list[ImapEmailProjection]
        """
        return self._results

    @results.setter
    def results(self, results):
        """Sets the results of this ImapServerSearchResult.


        :param results: The results of this ImapServerSearchResult.  # noqa: E501
        :type: list[ImapEmailProjection]
        """
        if self.local_vars_configuration.client_side_validation and results is None:  # noqa: E501
            raise ValueError("Invalid value for `results`, must not be `None`")  # noqa: E501

        self._results = results

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapServerSearchResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapServerSearchResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_server_search_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapServerSearchOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'seq_num': 'str',
        'uid': 'str',
        'since': 'datetime',
        'before': 'datetime',
        'sent_since': 'datetime',
        'sent_before': 'datetime',
        'header': 'dict(str, list[str])',
        'body': 'list[str]',
        'text': 'list[str]',
        'with_flags': 'list[str]',
        'without_flags': 'list[str]'
    }

    attribute_map = {
        'seq_num': 'seqNum',
        'uid': 'uid',
        'since': 'since',
        'before': 'before',
        'sent_since': 'sentSince',
        'sent_before': 'sentBefore',
        'header': 'header',
        'body': 'body',
        'text': 'text',
        'with_flags': 'withFlags',
        'without_flags': 'withoutFlags'
    }

    def __init__(self, seq_num=None, uid=None, since=None, before=None, sent_since=None, sent_before=None, header=None, body=None, text=None, with_flags=None, without_flags=None, local_vars_configuration=None):  # noqa: E501
        """ImapServerSearchOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._seq_num = None
        self._uid = None
        self._since = None
        self._before = None
        self._sent_since = None
        self._sent_before = None
        self._header = None
        self._body = None
        self._text = None
        self._with_flags = None
        self._without_flags = None
        self.discriminator = None

        self.seq_num = seq_num
        self.uid = uid
        self.since = since
        self.before = before
        self.sent_since = sent_since
        self.sent_before = sent_before
        self.header = header
        self.body = body
        self.text = text
        self.with_flags = with_flags
        self.without_flags = without_flags

    @property
    def seq_num(self):
        """Gets the seq_num of this ImapServerSearchOptions.  # noqa: E501


        :return: The seq_num of this ImapServerSearchOptions.  # noqa: E501
        :rtype: str
        """
        return self._seq_num

    @seq_num.setter
    def seq_num(self, seq_num):
        """Sets the seq_num of this ImapServerSearchOptions.


        :param seq_num: The seq_num of this ImapServerSearchOptions.  # noqa: E501
        :type: str
        """

        self._seq_num = seq_num

    @property
    def uid(self):
        """Gets the uid of this ImapServerSearchOptions.  # noqa: E501


        :return: The uid of this ImapServerSearchOptions.  # noqa: E501
        :rtype: str
        """
        return self._uid

    @uid.setter
    def uid(self, uid):
        """Sets the uid of this ImapServerSearchOptions.


        :param uid: The uid of this ImapServerSearchOptions.  # noqa: E501
        :type: str
        """

        self._uid = uid

    @property
    def since(self):
        """Gets the since of this ImapServerSearchOptions.  # noqa: E501


        :return: The since of this ImapServerSearchOptions.  # noqa: E501
        :rtype: datetime
        """
        return self._since

    @since.setter
    def since(self, since):
        """Sets the since of this ImapServerSearchOptions.


        :param since: The since of this ImapServerSearchOptions.  # noqa: E501
        :type: datetime
        """

        self._since = since

    @property
    def before(self):
        """Gets the before of this ImapServerSearchOptions.  # noqa: E501


        :return: The before of this ImapServerSearchOptions.  # noqa: E501
        :rtype: datetime
        """
        return self._before

    @before.setter
    def before(self, before):
        """Sets the before of this ImapServerSearchOptions.


        :param before: The before of this ImapServerSearchOptions.  # noqa: E501
        :type: datetime
        """

        self._before = before

    @property
    def sent_since(self):
        """Gets the sent_since of this ImapServerSearchOptions.  # noqa: E501


        :return: The sent_since of this ImapServerSearchOptions.  # noqa: E501
        :rtype: datetime
        """
        return self._sent_since

    @sent_since.setter
    def sent_since(self, sent_since):
        """Sets the sent_since of this ImapServerSearchOptions.


        :param sent_since: The sent_since of this ImapServerSearchOptions.  # noqa: E501
        :type: datetime
        """

        self._sent_since = sent_since

    @property
    def sent_before(self):
        """Gets the sent_before of this ImapServerSearchOptions.  # noqa: E501


        :return: The sent_before of this ImapServerSearchOptions.  # noqa: E501
        :rtype: datetime
        """
        return self._sent_before

    @sent_before.setter
    def sent_before(self, sent_before):
        """Sets the sent_before of this ImapServerSearchOptions.


        :param sent_before: The sent_before of this ImapServerSearchOptions.  # noqa: E501
        :type: datetime
        """

        self._sent_before = sent_before

    @property
    def header(self):
        """Gets the header of this ImapServerSearchOptions.  # noqa: E501


        :return: The header of this ImapServerSearchOptions.  # noqa: E501
        :rtype: dict(str, list[str])
        """
        return self._header

    @header.setter
    def header(self, header):
        """Sets the header of this ImapServerSearchOptions.


        :param header: The header of this ImapServerSearchOptions.  # noqa: E501
        :type: dict(str, list[str])
        """

        self._header = header

    @property
    def body(self):
        """Gets the body of this ImapServerSearchOptions.  # noqa: E501


        :return: The body of this ImapServerSearchOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this ImapServerSearchOptions.


        :param body: The body of this ImapServerSearchOptions.  # noqa: E501
        :type: list[str]
        """

        self._body = body

    @property
    def text(self):
        """Gets the text of this ImapServerSearchOptions.  # noqa: E501


        :return: The text of this ImapServerSearchOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._text

    @text.setter
    def text(self, text):
        """Sets the text of this ImapServerSearchOptions.


        :param text: The text of this ImapServerSearchOptions.  # noqa: E501
        :type: list[str]
        """

        self._text = text

    @property
    def with_flags(self):
        """Gets the with_flags of this ImapServerSearchOptions.  # noqa: E501


        :return: The with_flags of this ImapServerSearchOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._with_flags

    @with_flags.setter
    def with_flags(self, with_flags):
        """Sets the with_flags of this ImapServerSearchOptions.


        :param with_flags: The with_flags of this ImapServerSearchOptions.  # noqa: E501
        :type: list[str]
        """

        self._with_flags = with_flags

    @property
    def without_flags(self):
        """Gets the without_flags of this ImapServerSearchOptions.  # noqa: E501


        :return: The without_flags of this ImapServerSearchOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._without_flags

    @without_flags.setter
    def without_flags(self, without_flags):
        """Sets the without_flags of this ImapServerSearchOptions.


        :param without_flags: The without_flags of this ImapServerSearchOptions.  # noqa: E501
        :type: list[str]
        """

        self._without_flags = without_flags

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapServerSearchOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapServerSearchOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_server_mailbox_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapServerMailboxResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'message': 'str',
        'success': 'bool'
    }

    attribute_map = {
        'message': 'message',
        'success': 'success'
    }

    def __init__(self, message=None, success=None, local_vars_configuration=None):  # noqa: E501
        """ImapServerMailboxResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._message = None
        self._success = None
        self.discriminator = None

        self.message = message
        self.success = success

    @property
    def message(self):
        """Gets the message of this ImapServerMailboxResult.  # noqa: E501


        :return: The message of this ImapServerMailboxResult.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this ImapServerMailboxResult.


        :param message: The message of this ImapServerMailboxResult.  # noqa: E501
        :type: str
        """

        self._message = message

    @property
    def success(self):
        """Gets the success of this ImapServerMailboxResult.  # noqa: E501


        :return: The success of this ImapServerMailboxResult.  # noqa: E501
        :rtype: bool
        """
        return self._success

    @success.setter
    def success(self, success):
        """Sets the success of this ImapServerMailboxResult.


        :param success: The success of this ImapServerMailboxResult.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and success is None:  # noqa: E501
            raise ValueError("Invalid value for `success`, must not be `None`")  # noqa: E501

        self._success = success

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapServerMailboxResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapServerMailboxResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_server_list_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapServerListResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'results': 'list[ImapEmailProjection]'
    }

    attribute_map = {
        'results': 'results'
    }

    def __init__(self, results=None, local_vars_configuration=None):  # noqa: E501
        """ImapServerListResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._results = None
        self.discriminator = None

        self.results = results

    @property
    def results(self):
        """Gets the results of this ImapServerListResult.  # noqa: E501


        :return: The results of this ImapServerListResult.  # noqa: E501
        :rtype: list[ImapEmailProjection]
        """
        return self._results

    @results.setter
    def results(self, results):
        """Sets the results of this ImapServerListResult.


        :param results: The results of this ImapServerListResult.  # noqa: E501
        :type: list[ImapEmailProjection]
        """
        if self.local_vars_configuration.client_side_validation and results is None:  # noqa: E501
            raise ValueError("Invalid value for `results`, must not be `None`")  # noqa: E501

        self._results = results

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapServerListResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapServerListResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_server_list_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapServerListOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'uid_set': 'str',
        'seq_set': 'str'
    }

    attribute_map = {
        'uid_set': 'uidSet',
        'seq_set': 'seqSet'
    }

    def __init__(self, uid_set=None, seq_set=None, local_vars_configuration=None):  # noqa: E501
        """ImapServerListOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._uid_set = None
        self._seq_set = None
        self.discriminator = None

        self.uid_set = uid_set
        self.seq_set = seq_set

    @property
    def uid_set(self):
        """Gets the uid_set of this ImapServerListOptions.  # noqa: E501


        :return: The uid_set of this ImapServerListOptions.  # noqa: E501
        :rtype: str
        """
        return self._uid_set

    @uid_set.setter
    def uid_set(self, uid_set):
        """Sets the uid_set of this ImapServerListOptions.


        :param uid_set: The uid_set of this ImapServerListOptions.  # noqa: E501
        :type: str
        """

        self._uid_set = uid_set

    @property
    def seq_set(self):
        """Gets the seq_set of this ImapServerListOptions.  # noqa: E501


        :return: The seq_set of this ImapServerListOptions.  # noqa: E501
        :rtype: str
        """
        return self._seq_set

    @seq_set.setter
    def seq_set(self, seq_set):
        """Sets the seq_set of this ImapServerListOptions.


        :param seq_set: The seq_set of this ImapServerListOptions.  # noqa: E501
        :type: str
        """

        self._seq_set = seq_set

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapServerListOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapServerListOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_server_get_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapServerGetResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'result': 'ImapEmailProjection'
    }

    attribute_map = {
        'result': 'result'
    }

    def __init__(self, result=None, local_vars_configuration=None):  # noqa: E501
        """ImapServerGetResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._result = None
        self.discriminator = None

        if result is not None:
            self.result = result

    @property
    def result(self):
        """Gets the result of this ImapServerGetResult.  # noqa: E501


        :return: The result of this ImapServerGetResult.  # noqa: E501
        :rtype: ImapEmailProjection
        """
        return self._result

    @result.setter
    def result(self, result):
        """Sets the result of this ImapServerGetResult.


        :param result: The result of this ImapServerGetResult.  # noqa: E501
        :type: ImapEmailProjection
        """

        self._result = result

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapServerGetResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapServerGetResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_server_fetch_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapServerFetchResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'result': 'ImapServerFetchItem'
    }

    attribute_map = {
        'result': 'result'
    }

    def __init__(self, result=None, local_vars_configuration=None):  # noqa: E501
        """ImapServerFetchResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._result = None
        self.discriminator = None

        self.result = result

    @property
    def result(self):
        """Gets the result of this ImapServerFetchResult.  # noqa: E501


        :return: The result of this ImapServerFetchResult.  # noqa: E501
        :rtype: ImapServerFetchItem
        """
        return self._result

    @result.setter
    def result(self, result):
        """Sets the result of this ImapServerFetchResult.


        :param result: The result of this ImapServerFetchResult.  # noqa: E501
        :type: ImapServerFetchItem
        """

        self._result = result

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapServerFetchResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapServerFetchResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_server_fetch_item.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapServerFetchItem(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'str',
        'id': 'str',
        'uid': 'int',
        'seq_num': 'int',
        'read': 'bool'
    }

    attribute_map = {
        'content': 'content',
        'id': 'id',
        'uid': 'uid',
        'seq_num': 'seqNum',
        'read': 'read'
    }

    def __init__(self, content=None, id=None, uid=None, seq_num=None, read=None, local_vars_configuration=None):  # noqa: E501
        """ImapServerFetchItem - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self._id = None
        self._uid = None
        self._seq_num = None
        self._read = None
        self.discriminator = None

        self.content = content
        self.id = id
        self.uid = uid
        self.seq_num = seq_num
        self.read = read

    @property
    def content(self):
        """Gets the content of this ImapServerFetchItem.  # noqa: E501

        Content of the email  # noqa: E501

        :return: The content of this ImapServerFetchItem.  # noqa: E501
        :rtype: str
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this ImapServerFetchItem.

        Content of the email  # noqa: E501

        :param content: The content of this ImapServerFetchItem.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and content is None:  # noqa: E501
            raise ValueError("Invalid value for `content`, must not be `None`")  # noqa: E501

        self._content = content

    @property
    def id(self):
        """Gets the id of this ImapServerFetchItem.  # noqa: E501

        ID of the email  # noqa: E501

        :return: The id of this ImapServerFetchItem.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this ImapServerFetchItem.

        ID of the email  # noqa: E501

        :param id: The id of this ImapServerFetchItem.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def uid(self):
        """Gets the uid of this ImapServerFetchItem.  # noqa: E501

        UID of the email  # noqa: E501

        :return: The uid of this ImapServerFetchItem.  # noqa: E501
        :rtype: int
        """
        return self._uid

    @uid.setter
    def uid(self, uid):
        """Sets the uid of this ImapServerFetchItem.

        UID of the email  # noqa: E501

        :param uid: The uid of this ImapServerFetchItem.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and uid is None:  # noqa: E501
            raise ValueError("Invalid value for `uid`, must not be `None`")  # noqa: E501

        self._uid = uid

    @property
    def seq_num(self):
        """Gets the seq_num of this ImapServerFetchItem.  # noqa: E501

        Sequence number of the email  # noqa: E501

        :return: The seq_num of this ImapServerFetchItem.  # noqa: E501
        :rtype: int
        """
        return self._seq_num

    @seq_num.setter
    def seq_num(self, seq_num):
        """Sets the seq_num of this ImapServerFetchItem.

        Sequence number of the email  # noqa: E501

        :param seq_num: The seq_num of this ImapServerFetchItem.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and seq_num is None:  # noqa: E501
            raise ValueError("Invalid value for `seq_num`, must not be `None`")  # noqa: E501

        self._seq_num = seq_num

    @property
    def read(self):
        """Gets the read of this ImapServerFetchItem.  # noqa: E501

        Read status of the email  # noqa: E501

        :return: The read of this ImapServerFetchItem.  # noqa: E501
        :rtype: bool
        """
        return self._read

    @read.setter
    def read(self, read):
        """Sets the read of this ImapServerFetchItem.

        Read status of the email  # noqa: E501

        :param read: The read of this ImapServerFetchItem.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and read is None:  # noqa: E501
            raise ValueError("Invalid value for `read`, must not be `None`")  # noqa: E501

        self._read = read

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapServerFetchItem):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapServerFetchItem):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_mailbox_status.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapMailboxStatus(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'name': 'str',
        'read_only': 'bool',
        'items': 'object',
        'flags': 'list[str]',
        'permanent_flags': 'list[str]',
        'unseen_seq_num': 'int',
        'messages': 'int',
        'recent': 'int',
        'unseen': 'int',
        'uid_next': 'int',
        'uid_validity': 'int',
        'append_limit': 'int'
    }

    attribute_map = {
        'name': 'name',
        'read_only': 'readOnly',
        'items': 'items',
        'flags': 'flags',
        'permanent_flags': 'permanentFlags',
        'unseen_seq_num': 'unseenSeqNum',
        'messages': 'messages',
        'recent': 'recent',
        'unseen': 'unseen',
        'uid_next': 'uidNext',
        'uid_validity': 'uidValidity',
        'append_limit': 'appendLimit'
    }

    def __init__(self, name=None, read_only=None, items=None, flags=None, permanent_flags=None, unseen_seq_num=None, messages=None, recent=None, unseen=None, uid_next=None, uid_validity=None, append_limit=None, local_vars_configuration=None):  # noqa: E501
        """ImapMailboxStatus - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._name = None
        self._read_only = None
        self._items = None
        self._flags = None
        self._permanent_flags = None
        self._unseen_seq_num = None
        self._messages = None
        self._recent = None
        self._unseen = None
        self._uid_next = None
        self._uid_validity = None
        self._append_limit = None
        self.discriminator = None

        self.name = name
        self.read_only = read_only
        self.items = items
        self.flags = flags
        self.permanent_flags = permanent_flags
        self.unseen_seq_num = unseen_seq_num
        self.messages = messages
        self.recent = recent
        self.unseen = unseen
        self.uid_next = uid_next
        self.uid_validity = uid_validity
        self.append_limit = append_limit

    @property
    def name(self):
        """Gets the name of this ImapMailboxStatus.  # noqa: E501

        The mailbox name.  # noqa: E501

        :return: The name of this ImapMailboxStatus.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this ImapMailboxStatus.

        The mailbox name.  # noqa: E501

        :param name: The name of this ImapMailboxStatus.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    @property
    def read_only(self):
        """Gets the read_only of this ImapMailboxStatus.  # noqa: E501

        True if the mailbox is open in read-only mode.  # noqa: E501

        :return: The read_only of this ImapMailboxStatus.  # noqa: E501
        :rtype: bool
        """
        return self._read_only

    @read_only.setter
    def read_only(self, read_only):
        """Sets the read_only of this ImapMailboxStatus.

        True if the mailbox is open in read-only mode.  # noqa: E501

        :param read_only: The read_only of this ImapMailboxStatus.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and read_only is None:  # noqa: E501
            raise ValueError("Invalid value for `read_only`, must not be `None`")  # noqa: E501

        self._read_only = read_only

    @property
    def items(self):
        """Gets the items of this ImapMailboxStatus.  # noqa: E501

        Results map  # noqa: E501

        :return: The items of this ImapMailboxStatus.  # noqa: E501
        :rtype: object
        """
        return self._items

    @items.setter
    def items(self, items):
        """Sets the items of this ImapMailboxStatus.

        Results map  # noqa: E501

        :param items: The items of this ImapMailboxStatus.  # noqa: E501
        :type: object
        """

        self._items = items

    @property
    def flags(self):
        """Gets the flags of this ImapMailboxStatus.  # noqa: E501

        The mailbox flags.  # noqa: E501

        :return: The flags of this ImapMailboxStatus.  # noqa: E501
        :rtype: list[str]
        """
        return self._flags

    @flags.setter
    def flags(self, flags):
        """Sets the flags of this ImapMailboxStatus.

        The mailbox flags.  # noqa: E501

        :param flags: The flags of this ImapMailboxStatus.  # noqa: E501
        :type: list[str]
        """

        self._flags = flags

    @property
    def permanent_flags(self):
        """Gets the permanent_flags of this ImapMailboxStatus.  # noqa: E501

        The mailbox permanent flags.  # noqa: E501

        :return: The permanent_flags of this ImapMailboxStatus.  # noqa: E501
        :rtype: list[str]
        """
        return self._permanent_flags

    @permanent_flags.setter
    def permanent_flags(self, permanent_flags):
        """Sets the permanent_flags of this ImapMailboxStatus.

        The mailbox permanent flags.  # noqa: E501

        :param permanent_flags: The permanent_flags of this ImapMailboxStatus.  # noqa: E501
        :type: list[str]
        """

        self._permanent_flags = permanent_flags

    @property
    def unseen_seq_num(self):
        """Gets the unseen_seq_num of this ImapMailboxStatus.  # noqa: E501

        The sequence number of the first unseen message in the mailbox.  # noqa: E501

        :return: The unseen_seq_num of this ImapMailboxStatus.  # noqa: E501
        :rtype: int
        """
        return self._unseen_seq_num

    @unseen_seq_num.setter
    def unseen_seq_num(self, unseen_seq_num):
        """Sets the unseen_seq_num of this ImapMailboxStatus.

        The sequence number of the first unseen message in the mailbox.  # noqa: E501

        :param unseen_seq_num: The unseen_seq_num of this ImapMailboxStatus.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and unseen_seq_num is None:  # noqa: E501
            raise ValueError("Invalid value for `unseen_seq_num`, must not be `None`")  # noqa: E501

        self._unseen_seq_num = unseen_seq_num

    @property
    def messages(self):
        """Gets the messages of this ImapMailboxStatus.  # noqa: E501

        The number of messages in this mailbox.  # noqa: E501

        :return: The messages of this ImapMailboxStatus.  # noqa: E501
        :rtype: int
        """
        return self._messages

    @messages.setter
    def messages(self, messages):
        """Sets the messages of this ImapMailboxStatus.

        The number of messages in this mailbox.  # noqa: E501

        :param messages: The messages of this ImapMailboxStatus.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and messages is None:  # noqa: E501
            raise ValueError("Invalid value for `messages`, must not be `None`")  # noqa: E501

        self._messages = messages

    @property
    def recent(self):
        """Gets the recent of this ImapMailboxStatus.  # noqa: E501

        The number of messages not seen since the last time the mailbox was opened.  # noqa: E501

        :return: The recent of this ImapMailboxStatus.  # noqa: E501
        :rtype: int
        """
        return self._recent

    @recent.setter
    def recent(self, recent):
        """Sets the recent of this ImapMailboxStatus.

        The number of messages not seen since the last time the mailbox was opened.  # noqa: E501

        :param recent: The recent of this ImapMailboxStatus.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and recent is None:  # noqa: E501
            raise ValueError("Invalid value for `recent`, must not be `None`")  # noqa: E501

        self._recent = recent

    @property
    def unseen(self):
        """Gets the unseen of this ImapMailboxStatus.  # noqa: E501

        The number of unread messages.  # noqa: E501

        :return: The unseen of this ImapMailboxStatus.  # noqa: E501
        :rtype: int
        """
        return self._unseen

    @unseen.setter
    def unseen(self, unseen):
        """Sets the unseen of this ImapMailboxStatus.

        The number of unread messages.  # noqa: E501

        :param unseen: The unseen of this ImapMailboxStatus.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and unseen is None:  # noqa: E501
            raise ValueError("Invalid value for `unseen`, must not be `None`")  # noqa: E501

        self._unseen = unseen

    @property
    def uid_next(self):
        """Gets the uid_next of this ImapMailboxStatus.  # noqa: E501

        The next UID.  # noqa: E501

        :return: The uid_next of this ImapMailboxStatus.  # noqa: E501
        :rtype: int
        """
        return self._uid_next

    @uid_next.setter
    def uid_next(self, uid_next):
        """Sets the uid_next of this ImapMailboxStatus.

        The next UID.  # noqa: E501

        :param uid_next: The uid_next of this ImapMailboxStatus.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and uid_next is None:  # noqa: E501
            raise ValueError("Invalid value for `uid_next`, must not be `None`")  # noqa: E501

        self._uid_next = uid_next

    @property
    def uid_validity(self):
        """Gets the uid_validity of this ImapMailboxStatus.  # noqa: E501

        Together with a UID, it is a unique identifier for a message. Must be greater than or equal to 1.  # noqa: E501

        :return: The uid_validity of this ImapMailboxStatus.  # noqa: E501
        :rtype: int
        """
        return self._uid_validity

    @uid_validity.setter
    def uid_validity(self, uid_validity):
        """Sets the uid_validity of this ImapMailboxStatus.

        Together with a UID, it is a unique identifier for a message. Must be greater than or equal to 1.  # noqa: E501

        :param uid_validity: The uid_validity of this ImapMailboxStatus.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and uid_validity is None:  # noqa: E501
            raise ValueError("Invalid value for `uid_validity`, must not be `None`")  # noqa: E501

        self._uid_validity = uid_validity

    @property
    def append_limit(self):
        """Gets the append_limit of this ImapMailboxStatus.  # noqa: E501

        Per-mailbox limit of message size. Set only if server supports the APPENDLIMIT extension  # noqa: E501

        :return: The append_limit of this ImapMailboxStatus.  # noqa: E501
        :rtype: int
        """
        return self._append_limit

    @append_limit.setter
    def append_limit(self, append_limit):
        """Sets the append_limit of this ImapMailboxStatus.

        Per-mailbox limit of message size. Set only if server supports the APPENDLIMIT extension  # noqa: E501

        :param append_limit: The append_limit of this ImapMailboxStatus.  # noqa: E501
        :type: int
        """

        self._append_limit = append_limit

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapMailboxStatus):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapMailboxStatus):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_flag_operation_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapFlagOperationOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'flag_operation': 'str',
        'flags': 'list[str]'
    }

    attribute_map = {
        'flag_operation': 'flagOperation',
        'flags': 'flags'
    }

    def __init__(self, flag_operation=None, flags=None, local_vars_configuration=None):  # noqa: E501
        """ImapFlagOperationOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._flag_operation = None
        self._flags = None
        self.discriminator = None

        self.flag_operation = flag_operation
        self.flags = flags

    @property
    def flag_operation(self):
        """Gets the flag_operation of this ImapFlagOperationOptions.  # noqa: E501


        :return: The flag_operation of this ImapFlagOperationOptions.  # noqa: E501
        :rtype: str
        """
        return self._flag_operation

    @flag_operation.setter
    def flag_operation(self, flag_operation):
        """Sets the flag_operation of this ImapFlagOperationOptions.


        :param flag_operation: The flag_operation of this ImapFlagOperationOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and flag_operation is None:  # noqa: E501
            raise ValueError("Invalid value for `flag_operation`, must not be `None`")  # noqa: E501
        allowed_values = ["SET_FLAGS", "ADD_FLAGS", "REMOVE_FLAGS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and flag_operation not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `flag_operation` ({0}), must be one of {1}"  # noqa: E501
                .format(flag_operation, allowed_values)
            )

        self._flag_operation = flag_operation

    @property
    def flags(self):
        """Gets the flags of this ImapFlagOperationOptions.  # noqa: E501


        :return: The flags of this ImapFlagOperationOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._flags

    @flags.setter
    def flags(self, flags):
        """Sets the flags of this ImapFlagOperationOptions.


        :param flags: The flags of this ImapFlagOperationOptions.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and flags is None:  # noqa: E501
            raise ValueError("Invalid value for `flags`, must not be `None`")  # noqa: E501

        self._flags = flags

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapFlagOperationOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapFlagOperationOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_email_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapEmailProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'read': 'bool',
        'uid': 'int',
        'seq_num': 'int',
        'id': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'read': 'read',
        'uid': 'uid',
        'seq_num': 'seqNum',
        'id': 'id'
    }

    def __init__(self, created_at=None, read=None, uid=None, seq_num=None, id=None, local_vars_configuration=None):  # noqa: E501
        """ImapEmailProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._read = None
        self._uid = None
        self._seq_num = None
        self._id = None
        self.discriminator = None

        self.created_at = created_at
        self.read = read
        self.uid = uid
        self.seq_num = seq_num
        self.id = id

    @property
    def created_at(self):
        """Gets the created_at of this ImapEmailProjection.  # noqa: E501


        :return: The created_at of this ImapEmailProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this ImapEmailProjection.


        :param created_at: The created_at of this ImapEmailProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def read(self):
        """Gets the read of this ImapEmailProjection.  # noqa: E501


        :return: The read of this ImapEmailProjection.  # noqa: E501
        :rtype: bool
        """
        return self._read

    @read.setter
    def read(self, read):
        """Sets the read of this ImapEmailProjection.


        :param read: The read of this ImapEmailProjection.  # noqa: E501
        :type: bool
        """

        self._read = read

    @property
    def uid(self):
        """Gets the uid of this ImapEmailProjection.  # noqa: E501


        :return: The uid of this ImapEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._uid

    @uid.setter
    def uid(self, uid):
        """Sets the uid of this ImapEmailProjection.


        :param uid: The uid of this ImapEmailProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and uid is None:  # noqa: E501
            raise ValueError("Invalid value for `uid`, must not be `None`")  # noqa: E501

        self._uid = uid

    @property
    def seq_num(self):
        """Gets the seq_num of this ImapEmailProjection.  # noqa: E501


        :return: The seq_num of this ImapEmailProjection.  # noqa: E501
        :rtype: int
        """
        return self._seq_num

    @seq_num.setter
    def seq_num(self, seq_num):
        """Sets the seq_num of this ImapEmailProjection.


        :param seq_num: The seq_num of this ImapEmailProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and seq_num is None:  # noqa: E501
            raise ValueError("Invalid value for `seq_num`, must not be `None`")  # noqa: E501

        self._seq_num = seq_num

    @property
    def id(self):
        """Gets the id of this ImapEmailProjection.  # noqa: E501


        :return: The id of this ImapEmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this ImapEmailProjection.


        :param id: The id of this ImapEmailProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapEmailProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapEmailProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/imap_access_details.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImapAccessDetails(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'secure_imap_server_host': 'str',
        'secure_imap_server_port': 'int',
        'secure_imap_username': 'str',
        'secure_imap_password': 'str',
        'imap_server_host': 'str',
        'imap_server_port': 'int',
        'imap_username': 'str',
        'imap_password': 'str',
        'imap_mailbox': 'str'
    }

    attribute_map = {
        'secure_imap_server_host': 'secureImapServerHost',
        'secure_imap_server_port': 'secureImapServerPort',
        'secure_imap_username': 'secureImapUsername',
        'secure_imap_password': 'secureImapPassword',
        'imap_server_host': 'imapServerHost',
        'imap_server_port': 'imapServerPort',
        'imap_username': 'imapUsername',
        'imap_password': 'imapPassword',
        'imap_mailbox': 'imapMailbox'
    }

    def __init__(self, secure_imap_server_host=None, secure_imap_server_port=None, secure_imap_username=None, secure_imap_password=None, imap_server_host=None, imap_server_port=None, imap_username=None, imap_password=None, imap_mailbox=None, local_vars_configuration=None):  # noqa: E501
        """ImapAccessDetails - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._secure_imap_server_host = None
        self._secure_imap_server_port = None
        self._secure_imap_username = None
        self._secure_imap_password = None
        self._imap_server_host = None
        self._imap_server_port = None
        self._imap_username = None
        self._imap_password = None
        self._imap_mailbox = None
        self.discriminator = None

        self.secure_imap_server_host = secure_imap_server_host
        self.secure_imap_server_port = secure_imap_server_port
        self.secure_imap_username = secure_imap_username
        self.secure_imap_password = secure_imap_password
        self.imap_server_host = imap_server_host
        self.imap_server_port = imap_server_port
        self.imap_username = imap_username
        self.imap_password = imap_password
        self.imap_mailbox = imap_mailbox

    @property
    def secure_imap_server_host(self):
        """Gets the secure_imap_server_host of this ImapAccessDetails.  # noqa: E501

        Secure TLS IMAP server host domain  # noqa: E501

        :return: The secure_imap_server_host of this ImapAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._secure_imap_server_host

    @secure_imap_server_host.setter
    def secure_imap_server_host(self, secure_imap_server_host):
        """Sets the secure_imap_server_host of this ImapAccessDetails.

        Secure TLS IMAP server host domain  # noqa: E501

        :param secure_imap_server_host: The secure_imap_server_host of this ImapAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and secure_imap_server_host is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_imap_server_host`, must not be `None`")  # noqa: E501

        self._secure_imap_server_host = secure_imap_server_host

    @property
    def secure_imap_server_port(self):
        """Gets the secure_imap_server_port of this ImapAccessDetails.  # noqa: E501

        Secure TLS IMAP server host port  # noqa: E501

        :return: The secure_imap_server_port of this ImapAccessDetails.  # noqa: E501
        :rtype: int
        """
        return self._secure_imap_server_port

    @secure_imap_server_port.setter
    def secure_imap_server_port(self, secure_imap_server_port):
        """Sets the secure_imap_server_port of this ImapAccessDetails.

        Secure TLS IMAP server host port  # noqa: E501

        :param secure_imap_server_port: The secure_imap_server_port of this ImapAccessDetails.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and secure_imap_server_port is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_imap_server_port`, must not be `None`")  # noqa: E501

        self._secure_imap_server_port = secure_imap_server_port

    @property
    def secure_imap_username(self):
        """Gets the secure_imap_username of this ImapAccessDetails.  # noqa: E501

        Secure TLS IMAP username for login  # noqa: E501

        :return: The secure_imap_username of this ImapAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._secure_imap_username

    @secure_imap_username.setter
    def secure_imap_username(self, secure_imap_username):
        """Sets the secure_imap_username of this ImapAccessDetails.

        Secure TLS IMAP username for login  # noqa: E501

        :param secure_imap_username: The secure_imap_username of this ImapAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and secure_imap_username is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_imap_username`, must not be `None`")  # noqa: E501

        self._secure_imap_username = secure_imap_username

    @property
    def secure_imap_password(self):
        """Gets the secure_imap_password of this ImapAccessDetails.  # noqa: E501

        Secure TLS IMAP password for login  # noqa: E501

        :return: The secure_imap_password of this ImapAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._secure_imap_password

    @secure_imap_password.setter
    def secure_imap_password(self, secure_imap_password):
        """Sets the secure_imap_password of this ImapAccessDetails.

        Secure TLS IMAP password for login  # noqa: E501

        :param secure_imap_password: The secure_imap_password of this ImapAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and secure_imap_password is None:  # noqa: E501
            raise ValueError("Invalid value for `secure_imap_password`, must not be `None`")  # noqa: E501

        self._secure_imap_password = secure_imap_password

    @property
    def imap_server_host(self):
        """Gets the imap_server_host of this ImapAccessDetails.  # noqa: E501

        IMAP server host domain  # noqa: E501

        :return: The imap_server_host of this ImapAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._imap_server_host

    @imap_server_host.setter
    def imap_server_host(self, imap_server_host):
        """Sets the imap_server_host of this ImapAccessDetails.

        IMAP server host domain  # noqa: E501

        :param imap_server_host: The imap_server_host of this ImapAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and imap_server_host is None:  # noqa: E501
            raise ValueError("Invalid value for `imap_server_host`, must not be `None`")  # noqa: E501

        self._imap_server_host = imap_server_host

    @property
    def imap_server_port(self):
        """Gets the imap_server_port of this ImapAccessDetails.  # noqa: E501

        IMAP server host port  # noqa: E501

        :return: The imap_server_port of this ImapAccessDetails.  # noqa: E501
        :rtype: int
        """
        return self._imap_server_port

    @imap_server_port.setter
    def imap_server_port(self, imap_server_port):
        """Sets the imap_server_port of this ImapAccessDetails.

        IMAP server host port  # noqa: E501

        :param imap_server_port: The imap_server_port of this ImapAccessDetails.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and imap_server_port is None:  # noqa: E501
            raise ValueError("Invalid value for `imap_server_port`, must not be `None`")  # noqa: E501

        self._imap_server_port = imap_server_port

    @property
    def imap_username(self):
        """Gets the imap_username of this ImapAccessDetails.  # noqa: E501

        IMAP username for login  # noqa: E501

        :return: The imap_username of this ImapAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._imap_username

    @imap_username.setter
    def imap_username(self, imap_username):
        """Sets the imap_username of this ImapAccessDetails.

        IMAP username for login  # noqa: E501

        :param imap_username: The imap_username of this ImapAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and imap_username is None:  # noqa: E501
            raise ValueError("Invalid value for `imap_username`, must not be `None`")  # noqa: E501

        self._imap_username = imap_username

    @property
    def imap_password(self):
        """Gets the imap_password of this ImapAccessDetails.  # noqa: E501

        IMAP password for login  # noqa: E501

        :return: The imap_password of this ImapAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._imap_password

    @imap_password.setter
    def imap_password(self, imap_password):
        """Sets the imap_password of this ImapAccessDetails.

        IMAP password for login  # noqa: E501

        :param imap_password: The imap_password of this ImapAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and imap_password is None:  # noqa: E501
            raise ValueError("Invalid value for `imap_password`, must not be `None`")  # noqa: E501

        self._imap_password = imap_password

    @property
    def imap_mailbox(self):
        """Gets the imap_mailbox of this ImapAccessDetails.  # noqa: E501

        IMAP mailbox to SELECT  # noqa: E501

        :return: The imap_mailbox of this ImapAccessDetails.  # noqa: E501
        :rtype: str
        """
        return self._imap_mailbox

    @imap_mailbox.setter
    def imap_mailbox(self, imap_mailbox):
        """Sets the imap_mailbox of this ImapAccessDetails.

        IMAP mailbox to SELECT  # noqa: E501

        :param imap_mailbox: The imap_mailbox of this ImapAccessDetails.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and imap_mailbox is None:  # noqa: E501
            raise ValueError("Invalid value for `imap_mailbox`, must not be `None`")  # noqa: E501

        self._imap_mailbox = imap_mailbox

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImapAccessDetails):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImapAccessDetails):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/image_issue.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ImageIssue(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'url': 'str',
        'response_status': 'int',
        'severity': 'str',
        'message': 'str'
    }

    attribute_map = {
        'url': 'url',
        'response_status': 'responseStatus',
        'severity': 'severity',
        'message': 'message'
    }

    def __init__(self, url=None, response_status=None, severity=None, message=None, local_vars_configuration=None):  # noqa: E501
        """ImageIssue - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._url = None
        self._response_status = None
        self._severity = None
        self._message = None
        self.discriminator = None

        self.url = url
        if response_status is not None:
            self.response_status = response_status
        self.severity = severity
        self.message = message

    @property
    def url(self):
        """Gets the url of this ImageIssue.  # noqa: E501


        :return: The url of this ImageIssue.  # noqa: E501
        :rtype: str
        """
        return self._url

    @url.setter
    def url(self, url):
        """Sets the url of this ImageIssue.


        :param url: The url of this ImageIssue.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and url is None:  # noqa: E501
            raise ValueError("Invalid value for `url`, must not be `None`")  # noqa: E501

        self._url = url

    @property
    def response_status(self):
        """Gets the response_status of this ImageIssue.  # noqa: E501


        :return: The response_status of this ImageIssue.  # noqa: E501
        :rtype: int
        """
        return self._response_status

    @response_status.setter
    def response_status(self, response_status):
        """Sets the response_status of this ImageIssue.


        :param response_status: The response_status of this ImageIssue.  # noqa: E501
        :type: int
        """

        self._response_status = response_status

    @property
    def severity(self):
        """Gets the severity of this ImageIssue.  # noqa: E501


        :return: The severity of this ImageIssue.  # noqa: E501
        :rtype: str
        """
        return self._severity

    @severity.setter
    def severity(self, severity):
        """Sets the severity of this ImageIssue.


        :param severity: The severity of this ImageIssue.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and severity is None:  # noqa: E501
            raise ValueError("Invalid value for `severity`, must not be `None`")  # noqa: E501
        allowed_values = ["Warning", "Error"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and severity not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `severity` ({0}), must be one of {1}"  # noqa: E501
                .format(severity, allowed_values)
            )

        self._severity = severity

    @property
    def message(self):
        """Gets the message of this ImageIssue.  # noqa: E501


        :return: The message of this ImageIssue.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this ImageIssue.


        :param message: The message of this ImageIssue.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and message is None:  # noqa: E501
            raise ValueError("Invalid value for `message`, must not be `None`")  # noqa: E501

        self._message = message

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ImageIssue):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ImageIssue):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/html_validation_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class HTMLValidationResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'is_valid': 'bool',
        'infos': 'list[ValidationMessage]',
        'errors': 'list[ValidationMessage]',
        'warnings': 'list[ValidationMessage]'
    }

    attribute_map = {
        'is_valid': 'isValid',
        'infos': 'infos',
        'errors': 'errors',
        'warnings': 'warnings'
    }

    def __init__(self, is_valid=None, infos=None, errors=None, warnings=None, local_vars_configuration=None):  # noqa: E501
        """HTMLValidationResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._is_valid = None
        self._infos = None
        self._errors = None
        self._warnings = None
        self.discriminator = None

        self.is_valid = is_valid
        self.infos = infos
        self.errors = errors
        self.warnings = warnings

    @property
    def is_valid(self):
        """Gets the is_valid of this HTMLValidationResult.  # noqa: E501

        Is HTML validation result valid  # noqa: E501

        :return: The is_valid of this HTMLValidationResult.  # noqa: E501
        :rtype: bool
        """
        return self._is_valid

    @is_valid.setter
    def is_valid(self, is_valid):
        """Sets the is_valid of this HTMLValidationResult.

        Is HTML validation result valid  # noqa: E501

        :param is_valid: The is_valid of this HTMLValidationResult.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and is_valid is None:  # noqa: E501
            raise ValueError("Invalid value for `is_valid`, must not be `None`")  # noqa: E501

        self._is_valid = is_valid

    @property
    def infos(self):
        """Gets the infos of this HTMLValidationResult.  # noqa: E501

        Optional infos resulting from HTML validation  # noqa: E501

        :return: The infos of this HTMLValidationResult.  # noqa: E501
        :rtype: list[ValidationMessage]
        """
        return self._infos

    @infos.setter
    def infos(self, infos):
        """Sets the infos of this HTMLValidationResult.

        Optional infos resulting from HTML validation  # noqa: E501

        :param infos: The infos of this HTMLValidationResult.  # noqa: E501
        :type: list[ValidationMessage]
        """
        if self.local_vars_configuration.client_side_validation and infos is None:  # noqa: E501
            raise ValueError("Invalid value for `infos`, must not be `None`")  # noqa: E501

        self._infos = infos

    @property
    def errors(self):
        """Gets the errors of this HTMLValidationResult.  # noqa: E501

        Optional errors resulting from HTML validation  # noqa: E501

        :return: The errors of this HTMLValidationResult.  # noqa: E501
        :rtype: list[ValidationMessage]
        """
        return self._errors

    @errors.setter
    def errors(self, errors):
        """Sets the errors of this HTMLValidationResult.

        Optional errors resulting from HTML validation  # noqa: E501

        :param errors: The errors of this HTMLValidationResult.  # noqa: E501
        :type: list[ValidationMessage]
        """
        if self.local_vars_configuration.client_side_validation and errors is None:  # noqa: E501
            raise ValueError("Invalid value for `errors`, must not be `None`")  # noqa: E501

        self._errors = errors

    @property
    def warnings(self):
        """Gets the warnings of this HTMLValidationResult.  # noqa: E501

        Optional warnings resulting from HTML validation  # noqa: E501

        :return: The warnings of this HTMLValidationResult.  # noqa: E501
        :rtype: list[ValidationMessage]
        """
        return self._warnings

    @warnings.setter
    def warnings(self, warnings):
        """Sets the warnings of this HTMLValidationResult.

        Optional warnings resulting from HTML validation  # noqa: E501

        :param warnings: The warnings of this HTMLValidationResult.  # noqa: E501
        :type: list[ValidationMessage]
        """
        if self.local_vars_configuration.client_side_validation and warnings is None:  # noqa: E501
            raise ValueError("Invalid value for `warnings`, must not be `None`")  # noqa: E501

        self._warnings = warnings

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, HTMLValidationResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, HTMLValidationResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/group_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class GroupProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'name': 'str',
        'id': 'str',
        'description': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'name': 'name',
        'id': 'id',
        'description': 'description'
    }

    def __init__(self, created_at=None, name=None, id=None, description=None, local_vars_configuration=None):  # noqa: E501
        """GroupProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._name = None
        self._id = None
        self._description = None
        self.discriminator = None

        self.created_at = created_at
        self.name = name
        self.id = id
        self.description = description

    @property
    def created_at(self):
        """Gets the created_at of this GroupProjection.  # noqa: E501


        :return: The created_at of this GroupProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this GroupProjection.


        :param created_at: The created_at of this GroupProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def name(self):
        """Gets the name of this GroupProjection.  # noqa: E501


        :return: The name of this GroupProjection.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this GroupProjection.


        :param name: The name of this GroupProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    @property
    def id(self):
        """Gets the id of this GroupProjection.  # noqa: E501


        :return: The id of this GroupProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this GroupProjection.


        :param id: The id of this GroupProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def description(self):
        """Gets the description of this GroupProjection.  # noqa: E501


        :return: The description of this GroupProjection.  # noqa: E501
        :rtype: str
        """
        return self._description

    @description.setter
    def description(self, description):
        """Sets the description of this GroupProjection.


        :param description: The description of this GroupProjection.  # noqa: E501
        :type: str
        """

        self._description = description

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, GroupProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, GroupProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/group_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class GroupDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'name': 'str',
        'description': 'str',
        'created_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'name': 'name',
        'description': 'description',
        'created_at': 'createdAt'
    }

    def __init__(self, id=None, name=None, description=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """GroupDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._name = None
        self._description = None
        self._created_at = None
        self.discriminator = None

        self.id = id
        self.name = name
        self.description = description
        self.created_at = created_at

    @property
    def id(self):
        """Gets the id of this GroupDto.  # noqa: E501


        :return: The id of this GroupDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this GroupDto.


        :param id: The id of this GroupDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def name(self):
        """Gets the name of this GroupDto.  # noqa: E501


        :return: The name of this GroupDto.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this GroupDto.


        :param name: The name of this GroupDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    @property
    def description(self):
        """Gets the description of this GroupDto.  # noqa: E501


        :return: The description of this GroupDto.  # noqa: E501
        :rtype: str
        """
        return self._description

    @description.setter
    def description(self, description):
        """Sets the description of this GroupDto.


        :param description: The description of this GroupDto.  # noqa: E501
        :type: str
        """

        self._description = description

    @property
    def created_at(self):
        """Gets the created_at of this GroupDto.  # noqa: E501


        :return: The created_at of this GroupDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this GroupDto.


        :param created_at: The created_at of this GroupDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, GroupDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, GroupDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/group_contacts_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class GroupContactsDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'group': 'GroupDto',
        'contacts': 'list[ContactDto]'
    }

    attribute_map = {
        'group': 'group',
        'contacts': 'contacts'
    }

    def __init__(self, group=None, contacts=None, local_vars_configuration=None):  # noqa: E501
        """GroupContactsDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._group = None
        self._contacts = None
        self.discriminator = None

        self.group = group
        self.contacts = contacts

    @property
    def group(self):
        """Gets the group of this GroupContactsDto.  # noqa: E501


        :return: The group of this GroupContactsDto.  # noqa: E501
        :rtype: GroupDto
        """
        return self._group

    @group.setter
    def group(self, group):
        """Sets the group of this GroupContactsDto.


        :param group: The group of this GroupContactsDto.  # noqa: E501
        :type: GroupDto
        """
        if self.local_vars_configuration.client_side_validation and group is None:  # noqa: E501
            raise ValueError("Invalid value for `group`, must not be `None`")  # noqa: E501

        self._group = group

    @property
    def contacts(self):
        """Gets the contacts of this GroupContactsDto.  # noqa: E501


        :return: The contacts of this GroupContactsDto.  # noqa: E501
        :rtype: list[ContactDto]
        """
        return self._contacts

    @contacts.setter
    def contacts(self, contacts):
        """Sets the contacts of this GroupContactsDto.


        :param contacts: The contacts of this GroupContactsDto.  # noqa: E501
        :type: list[ContactDto]
        """
        if self.local_vars_configuration.client_side_validation and contacts is None:  # noqa: E501
            raise ValueError("Invalid value for `contacts`, must not be `None`")  # noqa: E501

        self._contacts = contacts

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, GroupContactsDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, GroupContactsDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/gravatar_url.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class GravatarUrl(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'url': 'str',
        'hash': 'str'
    }

    attribute_map = {
        'url': 'url',
        'hash': 'hash'
    }

    def __init__(self, url=None, hash=None, local_vars_configuration=None):  # noqa: E501
        """GravatarUrl - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._url = None
        self._hash = None
        self.discriminator = None

        self.url = url
        self.hash = hash

    @property
    def url(self):
        """Gets the url of this GravatarUrl.  # noqa: E501


        :return: The url of this GravatarUrl.  # noqa: E501
        :rtype: str
        """
        return self._url

    @url.setter
    def url(self, url):
        """Sets the url of this GravatarUrl.


        :param url: The url of this GravatarUrl.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and url is None:  # noqa: E501
            raise ValueError("Invalid value for `url`, must not be `None`")  # noqa: E501

        self._url = url

    @property
    def hash(self):
        """Gets the hash of this GravatarUrl.  # noqa: E501


        :return: The hash of this GravatarUrl.  # noqa: E501
        :rtype: str
        """
        return self._hash

    @hash.setter
    def hash(self, hash):
        """Sets the hash of this GravatarUrl.


        :param hash: The hash of this GravatarUrl.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and hash is None:  # noqa: E501
            raise ValueError("Invalid value for `hash`, must not be `None`")  # noqa: E501

        self._hash = hash

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, GravatarUrl):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, GravatarUrl):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/get_email_screenshot_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class GetEmailScreenshotOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'height': 'int',
        'width': 'int'
    }

    attribute_map = {
        'height': 'height',
        'width': 'width'
    }

    def __init__(self, height=None, width=None, local_vars_configuration=None):  # noqa: E501
        """GetEmailScreenshotOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._height = None
        self._width = None
        self.discriminator = None

        self.height = height
        self.width = width

    @property
    def height(self):
        """Gets the height of this GetEmailScreenshotOptions.  # noqa: E501

        Window height in pixels  # noqa: E501

        :return: The height of this GetEmailScreenshotOptions.  # noqa: E501
        :rtype: int
        """
        return self._height

    @height.setter
    def height(self, height):
        """Sets the height of this GetEmailScreenshotOptions.

        Window height in pixels  # noqa: E501

        :param height: The height of this GetEmailScreenshotOptions.  # noqa: E501
        :type: int
        """

        self._height = height

    @property
    def width(self):
        """Gets the width of this GetEmailScreenshotOptions.  # noqa: E501

        Window width in pixels  # noqa: E501

        :return: The width of this GetEmailScreenshotOptions.  # noqa: E501
        :rtype: int
        """
        return self._width

    @width.setter
    def width(self, width):
        """Sets the width of this GetEmailScreenshotOptions.

        Window width in pixels  # noqa: E501

        :param width: The width of this GetEmailScreenshotOptions.  # noqa: E501
        :type: int
        """

        self._width = width

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, GetEmailScreenshotOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, GetEmailScreenshotOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/generate_tls_reporting_record_results.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class GenerateTlsReportingRecordResults(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'name': 'str',
        'type': 'str',
        'ttl': 'int',
        'value': 'str'
    }

    attribute_map = {
        'name': 'name',
        'type': 'type',
        'ttl': 'ttl',
        'value': 'value'
    }

    def __init__(self, name=None, type=None, ttl=None, value=None, local_vars_configuration=None):  # noqa: E501
        """GenerateTlsReportingRecordResults - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._name = None
        self._type = None
        self._ttl = None
        self._value = None
        self.discriminator = None

        self.name = name
        self.type = type
        self.ttl = ttl
        self.value = value

    @property
    def name(self):
        """Gets the name of this GenerateTlsReportingRecordResults.  # noqa: E501


        :return: The name of this GenerateTlsReportingRecordResults.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this GenerateTlsReportingRecordResults.


        :param name: The name of this GenerateTlsReportingRecordResults.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    @property
    def type(self):
        """Gets the type of this GenerateTlsReportingRecordResults.  # noqa: E501

        Domain Name Server Record Types  # noqa: E501

        :return: The type of this GenerateTlsReportingRecordResults.  # noqa: E501
        :rtype: str
        """
        return self._type

    @type.setter
    def type(self, type):
        """Sets the type of this GenerateTlsReportingRecordResults.

        Domain Name Server Record Types  # noqa: E501

        :param type: The type of this GenerateTlsReportingRecordResults.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and type is None:  # noqa: E501
            raise ValueError("Invalid value for `type`, must not be `None`")  # noqa: E501
        allowed_values = ["A", "NS", "MD", "MF", "CNAME", "SOA", "MB", "MG", "MR", "NULL", "WKS", "PTR", "HINFO", "MINFO", "MX", "TXT", "RP", "AFSDB", "X25", "ISDN", "RT", "NSAP", "NSAP_PTR", "SIG", "KEY", "PX", "GPOS", "AAAA", "LOC", "NXT", "EID", "NIMLOC", "SRV", "ATMA", "NAPTR", "KX", "CERT", "A6", "DNAME", "SINK", "OPT", "APL", "DS", "SSHFP", "IPSECKEY", "RRSIG", "NSEC", "DNSKEY", "DHCID", "NSEC3", "NSEC3PARAM", "TLSA", "SMIMEA", "HIP", "NINFO", "RKEY", "TALINK", "CDS", "CDNSKEY", "OPENPGPKEY", "CSYNC", "ZONEMD", "SVCB", "HTTPS", "SPF", "UINFO", "UID", "GID", "UNSPEC", "NID", "L32", "L64", "LP", "EUI48", "EUI64", "TKEY", "TSIG", "IXFR", "AXFR", "MAILB", "MAILA", "ANY", "URI", "CAA", "AVC", "DOA", "AMTRELAY", "TA", "DLV"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `type` ({0}), must be one of {1}"  # noqa: E501
                .format(type, allowed_values)
            )

        self._type = type

    @property
    def ttl(self):
        """Gets the ttl of this GenerateTlsReportingRecordResults.  # noqa: E501


        :return: The ttl of this GenerateTlsReportingRecordResults.  # noqa: E501
        :rtype: int
        """
        return self._ttl

    @ttl.setter
    def ttl(self, ttl):
        """Sets the ttl of this GenerateTlsReportingRecordResults.


        :param ttl: The ttl of this GenerateTlsReportingRecordResults.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and ttl is None:  # noqa: E501
            raise ValueError("Invalid value for `ttl`, must not be `None`")  # noqa: E501

        self._ttl = ttl

    @property
    def value(self):
        """Gets the value of this GenerateTlsReportingRecordResults.  # noqa: E501


        :return: The value of this GenerateTlsReportingRecordResults.  # noqa: E501
        :rtype: str
        """
        return self._value

    @value.setter
    def value(self, value):
        """Sets the value of this GenerateTlsReportingRecordResults.


        :param value: The value of this GenerateTlsReportingRecordResults.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and value is None:  # noqa: E501
            raise ValueError("Invalid value for `value`, must not be `None`")  # noqa: E501

        self._value = value

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, GenerateTlsReportingRecordResults):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, GenerateTlsReportingRecordResults):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/generate_tls_reporting_record_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class GenerateTlsReportingRecordOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'reporting_addresses': 'list[str]',
        'reporting_url': 'str',
        'host': 'str',
        'version': 'str',
        'ttl': 'int'
    }

    attribute_map = {
        'reporting_addresses': 'reportingAddresses',
        'reporting_url': 'reportingUrl',
        'host': 'host',
        'version': 'version',
        'ttl': 'ttl'
    }

    def __init__(self, reporting_addresses=None, reporting_url=None, host=None, version=None, ttl=None, local_vars_configuration=None):  # noqa: E501
        """GenerateTlsReportingRecordOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._reporting_addresses = None
        self._reporting_url = None
        self._host = None
        self._version = None
        self._ttl = None
        self.discriminator = None

        self.reporting_addresses = reporting_addresses
        if reporting_url is not None:
            self.reporting_url = reporting_url
        self.host = host
        self.version = version
        self.ttl = ttl

    @property
    def reporting_addresses(self):
        """Gets the reporting_addresses of this GenerateTlsReportingRecordOptions.  # noqa: E501


        :return: The reporting_addresses of this GenerateTlsReportingRecordOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._reporting_addresses

    @reporting_addresses.setter
    def reporting_addresses(self, reporting_addresses):
        """Sets the reporting_addresses of this GenerateTlsReportingRecordOptions.


        :param reporting_addresses: The reporting_addresses of this GenerateTlsReportingRecordOptions.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and reporting_addresses is None:  # noqa: E501
            raise ValueError("Invalid value for `reporting_addresses`, must not be `None`")  # noqa: E501

        self._reporting_addresses = reporting_addresses

    @property
    def reporting_url(self):
        """Gets the reporting_url of this GenerateTlsReportingRecordOptions.  # noqa: E501


        :return: The reporting_url of this GenerateTlsReportingRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._reporting_url

    @reporting_url.setter
    def reporting_url(self, reporting_url):
        """Sets the reporting_url of this GenerateTlsReportingRecordOptions.


        :param reporting_url: The reporting_url of this GenerateTlsReportingRecordOptions.  # noqa: E501
        :type: str
        """

        self._reporting_url = reporting_url

    @property
    def host(self):
        """Gets the host of this GenerateTlsReportingRecordOptions.  # noqa: E501


        :return: The host of this GenerateTlsReportingRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._host

    @host.setter
    def host(self, host):
        """Sets the host of this GenerateTlsReportingRecordOptions.


        :param host: The host of this GenerateTlsReportingRecordOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and host is None:  # noqa: E501
            raise ValueError("Invalid value for `host`, must not be `None`")  # noqa: E501

        self._host = host

    @property
    def version(self):
        """Gets the version of this GenerateTlsReportingRecordOptions.  # noqa: E501


        :return: The version of this GenerateTlsReportingRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._version

    @version.setter
    def version(self, version):
        """Sets the version of this GenerateTlsReportingRecordOptions.


        :param version: The version of this GenerateTlsReportingRecordOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and version is None:  # noqa: E501
            raise ValueError("Invalid value for `version`, must not be `None`")  # noqa: E501
        allowed_values = ["TLSRPTv1"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and version not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `version` ({0}), must be one of {1}"  # noqa: E501
                .format(version, allowed_values)
            )

        self._version = version

    @property
    def ttl(self):
        """Gets the ttl of this GenerateTlsReportingRecordOptions.  # noqa: E501


        :return: The ttl of this GenerateTlsReportingRecordOptions.  # noqa: E501
        :rtype: int
        """
        return self._ttl

    @ttl.setter
    def ttl(self, ttl):
        """Sets the ttl of this GenerateTlsReportingRecordOptions.


        :param ttl: The ttl of this GenerateTlsReportingRecordOptions.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and ttl is None:  # noqa: E501
            raise ValueError("Invalid value for `ttl`, must not be `None`")  # noqa: E501

        self._ttl = ttl

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, GenerateTlsReportingRecordOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, GenerateTlsReportingRecordOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/generate_mta_sts_record_results.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class GenerateMtaStsRecordResults(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'name': 'str',
        'type': 'str',
        'ttl': 'int',
        'value': 'str',
        'well_known_value': 'str',
        'well_known_url': 'str'
    }

    attribute_map = {
        'name': 'name',
        'type': 'type',
        'ttl': 'ttl',
        'value': 'value',
        'well_known_value': 'wellKnownValue',
        'well_known_url': 'wellKnownUrl'
    }

    def __init__(self, name=None, type=None, ttl=None, value=None, well_known_value=None, well_known_url=None, local_vars_configuration=None):  # noqa: E501
        """GenerateMtaStsRecordResults - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._name = None
        self._type = None
        self._ttl = None
        self._value = None
        self._well_known_value = None
        self._well_known_url = None
        self.discriminator = None

        self.name = name
        self.type = type
        self.ttl = ttl
        self.value = value
        self.well_known_value = well_known_value
        self.well_known_url = well_known_url

    @property
    def name(self):
        """Gets the name of this GenerateMtaStsRecordResults.  # noqa: E501


        :return: The name of this GenerateMtaStsRecordResults.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this GenerateMtaStsRecordResults.


        :param name: The name of this GenerateMtaStsRecordResults.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    @property
    def type(self):
        """Gets the type of this GenerateMtaStsRecordResults.  # noqa: E501

        Domain Name Server Record Types  # noqa: E501

        :return: The type of this GenerateMtaStsRecordResults.  # noqa: E501
        :rtype: str
        """
        return self._type

    @type.setter
    def type(self, type):
        """Sets the type of this GenerateMtaStsRecordResults.

        Domain Name Server Record Types  # noqa: E501

        :param type: The type of this GenerateMtaStsRecordResults.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and type is None:  # noqa: E501
            raise ValueError("Invalid value for `type`, must not be `None`")  # noqa: E501
        allowed_values = ["A", "NS", "MD", "MF", "CNAME", "SOA", "MB", "MG", "MR", "NULL", "WKS", "PTR", "HINFO", "MINFO", "MX", "TXT", "RP", "AFSDB", "X25", "ISDN", "RT", "NSAP", "NSAP_PTR", "SIG", "KEY", "PX", "GPOS", "AAAA", "LOC", "NXT", "EID", "NIMLOC", "SRV", "ATMA", "NAPTR", "KX", "CERT", "A6", "DNAME", "SINK", "OPT", "APL", "DS", "SSHFP", "IPSECKEY", "RRSIG", "NSEC", "DNSKEY", "DHCID", "NSEC3", "NSEC3PARAM", "TLSA", "SMIMEA", "HIP", "NINFO", "RKEY", "TALINK", "CDS", "CDNSKEY", "OPENPGPKEY", "CSYNC", "ZONEMD", "SVCB", "HTTPS", "SPF", "UINFO", "UID", "GID", "UNSPEC", "NID", "L32", "L64", "LP", "EUI48", "EUI64", "TKEY", "TSIG", "IXFR", "AXFR", "MAILB", "MAILA", "ANY", "URI", "CAA", "AVC", "DOA", "AMTRELAY", "TA", "DLV"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `type` ({0}), must be one of {1}"  # noqa: E501
                .format(type, allowed_values)
            )

        self._type = type

    @property
    def ttl(self):
        """Gets the ttl of this GenerateMtaStsRecordResults.  # noqa: E501


        :return: The ttl of this GenerateMtaStsRecordResults.  # noqa: E501
        :rtype: int
        """
        return self._ttl

    @ttl.setter
    def ttl(self, ttl):
        """Sets the ttl of this GenerateMtaStsRecordResults.


        :param ttl: The ttl of this GenerateMtaStsRecordResults.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and ttl is None:  # noqa: E501
            raise ValueError("Invalid value for `ttl`, must not be `None`")  # noqa: E501

        self._ttl = ttl

    @property
    def value(self):
        """Gets the value of this GenerateMtaStsRecordResults.  # noqa: E501


        :return: The value of this GenerateMtaStsRecordResults.  # noqa: E501
        :rtype: str
        """
        return self._value

    @value.setter
    def value(self, value):
        """Sets the value of this GenerateMtaStsRecordResults.


        :param value: The value of this GenerateMtaStsRecordResults.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and value is None:  # noqa: E501
            raise ValueError("Invalid value for `value`, must not be `None`")  # noqa: E501

        self._value = value

    @property
    def well_known_value(self):
        """Gets the well_known_value of this GenerateMtaStsRecordResults.  # noqa: E501


        :return: The well_known_value of this GenerateMtaStsRecordResults.  # noqa: E501
        :rtype: str
        """
        return self._well_known_value

    @well_known_value.setter
    def well_known_value(self, well_known_value):
        """Sets the well_known_value of this GenerateMtaStsRecordResults.


        :param well_known_value: The well_known_value of this GenerateMtaStsRecordResults.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and well_known_value is None:  # noqa: E501
            raise ValueError("Invalid value for `well_known_value`, must not be `None`")  # noqa: E501

        self._well_known_value = well_known_value

    @property
    def well_known_url(self):
        """Gets the well_known_url of this GenerateMtaStsRecordResults.  # noqa: E501


        :return: The well_known_url of this GenerateMtaStsRecordResults.  # noqa: E501
        :rtype: str
        """
        return self._well_known_url

    @well_known_url.setter
    def well_known_url(self, well_known_url):
        """Sets the well_known_url of this GenerateMtaStsRecordResults.


        :param well_known_url: The well_known_url of this GenerateMtaStsRecordResults.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and well_known_url is None:  # noqa: E501
            raise ValueError("Invalid value for `well_known_url`, must not be `None`")  # noqa: E501

        self._well_known_url = well_known_url

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, GenerateMtaStsRecordResults):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, GenerateMtaStsRecordResults):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/generate_mta_sts_record_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class GenerateMtaStsRecordOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'host': 'str',
        'version': 'str',
        'mode': 'str',
        'ttl': 'int',
        'max_age_seconds': 'int',
        'mx_records': 'list[str]'
    }

    attribute_map = {
        'host': 'host',
        'version': 'version',
        'mode': 'mode',
        'ttl': 'ttl',
        'max_age_seconds': 'maxAgeSeconds',
        'mx_records': 'mxRecords'
    }

    def __init__(self, host=None, version=None, mode=None, ttl=None, max_age_seconds=None, mx_records=None, local_vars_configuration=None):  # noqa: E501
        """GenerateMtaStsRecordOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._host = None
        self._version = None
        self._mode = None
        self._ttl = None
        self._max_age_seconds = None
        self._mx_records = None
        self.discriminator = None

        self.host = host
        self.version = version
        self.mode = mode
        self.ttl = ttl
        self.max_age_seconds = max_age_seconds
        self.mx_records = mx_records

    @property
    def host(self):
        """Gets the host of this GenerateMtaStsRecordOptions.  # noqa: E501


        :return: The host of this GenerateMtaStsRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._host

    @host.setter
    def host(self, host):
        """Sets the host of this GenerateMtaStsRecordOptions.


        :param host: The host of this GenerateMtaStsRecordOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and host is None:  # noqa: E501
            raise ValueError("Invalid value for `host`, must not be `None`")  # noqa: E501

        self._host = host

    @property
    def version(self):
        """Gets the version of this GenerateMtaStsRecordOptions.  # noqa: E501


        :return: The version of this GenerateMtaStsRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._version

    @version.setter
    def version(self, version):
        """Sets the version of this GenerateMtaStsRecordOptions.


        :param version: The version of this GenerateMtaStsRecordOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and version is None:  # noqa: E501
            raise ValueError("Invalid value for `version`, must not be `None`")  # noqa: E501
        allowed_values = ["STSv1"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and version not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `version` ({0}), must be one of {1}"  # noqa: E501
                .format(version, allowed_values)
            )

        self._version = version

    @property
    def mode(self):
        """Gets the mode of this GenerateMtaStsRecordOptions.  # noqa: E501


        :return: The mode of this GenerateMtaStsRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._mode

    @mode.setter
    def mode(self, mode):
        """Sets the mode of this GenerateMtaStsRecordOptions.


        :param mode: The mode of this GenerateMtaStsRecordOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and mode is None:  # noqa: E501
            raise ValueError("Invalid value for `mode`, must not be `None`")  # noqa: E501
        allowed_values = ["TESTING", "ENFORCE", "NONE"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and mode not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `mode` ({0}), must be one of {1}"  # noqa: E501
                .format(mode, allowed_values)
            )

        self._mode = mode

    @property
    def ttl(self):
        """Gets the ttl of this GenerateMtaStsRecordOptions.  # noqa: E501


        :return: The ttl of this GenerateMtaStsRecordOptions.  # noqa: E501
        :rtype: int
        """
        return self._ttl

    @ttl.setter
    def ttl(self, ttl):
        """Sets the ttl of this GenerateMtaStsRecordOptions.


        :param ttl: The ttl of this GenerateMtaStsRecordOptions.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and ttl is None:  # noqa: E501
            raise ValueError("Invalid value for `ttl`, must not be `None`")  # noqa: E501

        self._ttl = ttl

    @property
    def max_age_seconds(self):
        """Gets the max_age_seconds of this GenerateMtaStsRecordOptions.  # noqa: E501


        :return: The max_age_seconds of this GenerateMtaStsRecordOptions.  # noqa: E501
        :rtype: int
        """
        return self._max_age_seconds

    @max_age_seconds.setter
    def max_age_seconds(self, max_age_seconds):
        """Sets the max_age_seconds of this GenerateMtaStsRecordOptions.


        :param max_age_seconds: The max_age_seconds of this GenerateMtaStsRecordOptions.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and max_age_seconds is None:  # noqa: E501
            raise ValueError("Invalid value for `max_age_seconds`, must not be `None`")  # noqa: E501

        self._max_age_seconds = max_age_seconds

    @property
    def mx_records(self):
        """Gets the mx_records of this GenerateMtaStsRecordOptions.  # noqa: E501


        :return: The mx_records of this GenerateMtaStsRecordOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._mx_records

    @mx_records.setter
    def mx_records(self, mx_records):
        """Sets the mx_records of this GenerateMtaStsRecordOptions.


        :param mx_records: The mx_records of this GenerateMtaStsRecordOptions.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and mx_records is None:  # noqa: E501
            raise ValueError("Invalid value for `mx_records`, must not be `None`")  # noqa: E501

        self._mx_records = mx_records

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, GenerateMtaStsRecordOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, GenerateMtaStsRecordOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/generate_dmarc_record_results.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class GenerateDmarcRecordResults(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'name': 'str',
        'type': 'str',
        'ttl': 'int',
        'value': 'str'
    }

    attribute_map = {
        'name': 'name',
        'type': 'type',
        'ttl': 'ttl',
        'value': 'value'
    }

    def __init__(self, name=None, type=None, ttl=None, value=None, local_vars_configuration=None):  # noqa: E501
        """GenerateDmarcRecordResults - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._name = None
        self._type = None
        self._ttl = None
        self._value = None
        self.discriminator = None

        self.name = name
        self.type = type
        self.ttl = ttl
        self.value = value

    @property
    def name(self):
        """Gets the name of this GenerateDmarcRecordResults.  # noqa: E501


        :return: The name of this GenerateDmarcRecordResults.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this GenerateDmarcRecordResults.


        :param name: The name of this GenerateDmarcRecordResults.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    @property
    def type(self):
        """Gets the type of this GenerateDmarcRecordResults.  # noqa: E501

        Domain Name Server Record Types  # noqa: E501

        :return: The type of this GenerateDmarcRecordResults.  # noqa: E501
        :rtype: str
        """
        return self._type

    @type.setter
    def type(self, type):
        """Sets the type of this GenerateDmarcRecordResults.

        Domain Name Server Record Types  # noqa: E501

        :param type: The type of this GenerateDmarcRecordResults.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and type is None:  # noqa: E501
            raise ValueError("Invalid value for `type`, must not be `None`")  # noqa: E501
        allowed_values = ["A", "NS", "MD", "MF", "CNAME", "SOA", "MB", "MG", "MR", "NULL", "WKS", "PTR", "HINFO", "MINFO", "MX", "TXT", "RP", "AFSDB", "X25", "ISDN", "RT", "NSAP", "NSAP_PTR", "SIG", "KEY", "PX", "GPOS", "AAAA", "LOC", "NXT", "EID", "NIMLOC", "SRV", "ATMA", "NAPTR", "KX", "CERT", "A6", "DNAME", "SINK", "OPT", "APL", "DS", "SSHFP", "IPSECKEY", "RRSIG", "NSEC", "DNSKEY", "DHCID", "NSEC3", "NSEC3PARAM", "TLSA", "SMIMEA", "HIP", "NINFO", "RKEY", "TALINK", "CDS", "CDNSKEY", "OPENPGPKEY", "CSYNC", "ZONEMD", "SVCB", "HTTPS", "SPF", "UINFO", "UID", "GID", "UNSPEC", "NID", "L32", "L64", "LP", "EUI48", "EUI64", "TKEY", "TSIG", "IXFR", "AXFR", "MAILB", "MAILA", "ANY", "URI", "CAA", "AVC", "DOA", "AMTRELAY", "TA", "DLV"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `type` ({0}), must be one of {1}"  # noqa: E501
                .format(type, allowed_values)
            )

        self._type = type

    @property
    def ttl(self):
        """Gets the ttl of this GenerateDmarcRecordResults.  # noqa: E501


        :return: The ttl of this GenerateDmarcRecordResults.  # noqa: E501
        :rtype: int
        """
        return self._ttl

    @ttl.setter
    def ttl(self, ttl):
        """Sets the ttl of this GenerateDmarcRecordResults.


        :param ttl: The ttl of this GenerateDmarcRecordResults.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and ttl is None:  # noqa: E501
            raise ValueError("Invalid value for `ttl`, must not be `None`")  # noqa: E501

        self._ttl = ttl

    @property
    def value(self):
        """Gets the value of this GenerateDmarcRecordResults.  # noqa: E501


        :return: The value of this GenerateDmarcRecordResults.  # noqa: E501
        :rtype: str
        """
        return self._value

    @value.setter
    def value(self, value):
        """Sets the value of this GenerateDmarcRecordResults.


        :param value: The value of this GenerateDmarcRecordResults.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and value is None:  # noqa: E501
            raise ValueError("Invalid value for `value`, must not be `None`")  # noqa: E501

        self._value = value

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, GenerateDmarcRecordResults):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, GenerateDmarcRecordResults):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/generate_dmarc_record_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class GenerateDmarcRecordOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'domain': 'str',
        'version': 'str',
        'policy': 'str',
        'subdomain_policy': 'str',
        'report_email_address': 'list[str]',
        'forensic_email_address': 'list[str]',
        'percentage': 'int',
        'report_format': 'str',
        'seconds_between_reports': 'int',
        'adkim': 'str',
        'aspf': 'str',
        'fo': 'str'
    }

    attribute_map = {
        'domain': 'domain',
        'version': 'version',
        'policy': 'policy',
        'subdomain_policy': 'subdomainPolicy',
        'report_email_address': 'reportEmailAddress',
        'forensic_email_address': 'forensicEmailAddress',
        'percentage': 'percentage',
        'report_format': 'reportFormat',
        'seconds_between_reports': 'secondsBetweenReports',
        'adkim': 'adkim',
        'aspf': 'aspf',
        'fo': 'fo'
    }

    def __init__(self, domain=None, version=None, policy=None, subdomain_policy=None, report_email_address=None, forensic_email_address=None, percentage=None, report_format=None, seconds_between_reports=None, adkim=None, aspf=None, fo=None, local_vars_configuration=None):  # noqa: E501
        """GenerateDmarcRecordOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._domain = None
        self._version = None
        self._policy = None
        self._subdomain_policy = None
        self._report_email_address = None
        self._forensic_email_address = None
        self._percentage = None
        self._report_format = None
        self._seconds_between_reports = None
        self._adkim = None
        self._aspf = None
        self._fo = None
        self.discriminator = None

        self.domain = domain
        self.version = version
        self.policy = policy
        if subdomain_policy is not None:
            self.subdomain_policy = subdomain_policy
        if report_email_address is not None:
            self.report_email_address = report_email_address
        if forensic_email_address is not None:
            self.forensic_email_address = forensic_email_address
        if percentage is not None:
            self.percentage = percentage
        if report_format is not None:
            self.report_format = report_format
        if seconds_between_reports is not None:
            self.seconds_between_reports = seconds_between_reports
        if adkim is not None:
            self.adkim = adkim
        if aspf is not None:
            self.aspf = aspf
        if fo is not None:
            self.fo = fo

    @property
    def domain(self):
        """Gets the domain of this GenerateDmarcRecordOptions.  # noqa: E501


        :return: The domain of this GenerateDmarcRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._domain

    @domain.setter
    def domain(self, domain):
        """Sets the domain of this GenerateDmarcRecordOptions.


        :param domain: The domain of this GenerateDmarcRecordOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and domain is None:  # noqa: E501
            raise ValueError("Invalid value for `domain`, must not be `None`")  # noqa: E501

        self._domain = domain

    @property
    def version(self):
        """Gets the version of this GenerateDmarcRecordOptions.  # noqa: E501


        :return: The version of this GenerateDmarcRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._version

    @version.setter
    def version(self, version):
        """Sets the version of this GenerateDmarcRecordOptions.


        :param version: The version of this GenerateDmarcRecordOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and version is None:  # noqa: E501
            raise ValueError("Invalid value for `version`, must not be `None`")  # noqa: E501
        allowed_values = ["DMARC1"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and version not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `version` ({0}), must be one of {1}"  # noqa: E501
                .format(version, allowed_values)
            )

        self._version = version

    @property
    def policy(self):
        """Gets the policy of this GenerateDmarcRecordOptions.  # noqa: E501


        :return: The policy of this GenerateDmarcRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._policy

    @policy.setter
    def policy(self, policy):
        """Sets the policy of this GenerateDmarcRecordOptions.


        :param policy: The policy of this GenerateDmarcRecordOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and policy is None:  # noqa: E501
            raise ValueError("Invalid value for `policy`, must not be `None`")  # noqa: E501
        allowed_values = ["NONE", "QUARANTINE", "REJECT"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and policy not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `policy` ({0}), must be one of {1}"  # noqa: E501
                .format(policy, allowed_values)
            )

        self._policy = policy

    @property
    def subdomain_policy(self):
        """Gets the subdomain_policy of this GenerateDmarcRecordOptions.  # noqa: E501


        :return: The subdomain_policy of this GenerateDmarcRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._subdomain_policy

    @subdomain_policy.setter
    def subdomain_policy(self, subdomain_policy):
        """Sets the subdomain_policy of this GenerateDmarcRecordOptions.


        :param subdomain_policy: The subdomain_policy of this GenerateDmarcRecordOptions.  # noqa: E501
        :type: str
        """
        allowed_values = ["NONE", "QUARANTINE", "REJECT"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and subdomain_policy not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `subdomain_policy` ({0}), must be one of {1}"  # noqa: E501
                .format(subdomain_policy, allowed_values)
            )

        self._subdomain_policy = subdomain_policy

    @property
    def report_email_address(self):
        """Gets the report_email_address of this GenerateDmarcRecordOptions.  # noqa: E501


        :return: The report_email_address of this GenerateDmarcRecordOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._report_email_address

    @report_email_address.setter
    def report_email_address(self, report_email_address):
        """Sets the report_email_address of this GenerateDmarcRecordOptions.


        :param report_email_address: The report_email_address of this GenerateDmarcRecordOptions.  # noqa: E501
        :type: list[str]
        """

        self._report_email_address = report_email_address

    @property
    def forensic_email_address(self):
        """Gets the forensic_email_address of this GenerateDmarcRecordOptions.  # noqa: E501


        :return: The forensic_email_address of this GenerateDmarcRecordOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._forensic_email_address

    @forensic_email_address.setter
    def forensic_email_address(self, forensic_email_address):
        """Sets the forensic_email_address of this GenerateDmarcRecordOptions.


        :param forensic_email_address: The forensic_email_address of this GenerateDmarcRecordOptions.  # noqa: E501
        :type: list[str]
        """

        self._forensic_email_address = forensic_email_address

    @property
    def percentage(self):
        """Gets the percentage of this GenerateDmarcRecordOptions.  # noqa: E501


        :return: The percentage of this GenerateDmarcRecordOptions.  # noqa: E501
        :rtype: int
        """
        return self._percentage

    @percentage.setter
    def percentage(self, percentage):
        """Sets the percentage of this GenerateDmarcRecordOptions.


        :param percentage: The percentage of this GenerateDmarcRecordOptions.  # noqa: E501
        :type: int
        """
        if (self.local_vars_configuration.client_side_validation and
                percentage is not None and percentage > 100):  # noqa: E501
            raise ValueError("Invalid value for `percentage`, must be a value less than or equal to `100`")  # noqa: E501
        if (self.local_vars_configuration.client_side_validation and
                percentage is not None and percentage < 1):  # noqa: E501
            raise ValueError("Invalid value for `percentage`, must be a value greater than or equal to `1`")  # noqa: E501

        self._percentage = percentage

    @property
    def report_format(self):
        """Gets the report_format of this GenerateDmarcRecordOptions.  # noqa: E501


        :return: The report_format of this GenerateDmarcRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._report_format

    @report_format.setter
    def report_format(self, report_format):
        """Sets the report_format of this GenerateDmarcRecordOptions.


        :param report_format: The report_format of this GenerateDmarcRecordOptions.  # noqa: E501
        :type: str
        """
        allowed_values = ["AFRF"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and report_format not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `report_format` ({0}), must be one of {1}"  # noqa: E501
                .format(report_format, allowed_values)
            )

        self._report_format = report_format

    @property
    def seconds_between_reports(self):
        """Gets the seconds_between_reports of this GenerateDmarcRecordOptions.  # noqa: E501


        :return: The seconds_between_reports of this GenerateDmarcRecordOptions.  # noqa: E501
        :rtype: int
        """
        return self._seconds_between_reports

    @seconds_between_reports.setter
    def seconds_between_reports(self, seconds_between_reports):
        """Sets the seconds_between_reports of this GenerateDmarcRecordOptions.


        :param seconds_between_reports: The seconds_between_reports of this GenerateDmarcRecordOptions.  # noqa: E501
        :type: int
        """

        self._seconds_between_reports = seconds_between_reports

    @property
    def adkim(self):
        """Gets the adkim of this GenerateDmarcRecordOptions.  # noqa: E501


        :return: The adkim of this GenerateDmarcRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._adkim

    @adkim.setter
    def adkim(self, adkim):
        """Sets the adkim of this GenerateDmarcRecordOptions.


        :param adkim: The adkim of this GenerateDmarcRecordOptions.  # noqa: E501
        :type: str
        """
        allowed_values = ["STRICT", "RELAXED"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and adkim not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `adkim` ({0}), must be one of {1}"  # noqa: E501
                .format(adkim, allowed_values)
            )

        self._adkim = adkim

    @property
    def aspf(self):
        """Gets the aspf of this GenerateDmarcRecordOptions.  # noqa: E501


        :return: The aspf of this GenerateDmarcRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._aspf

    @aspf.setter
    def aspf(self, aspf):
        """Sets the aspf of this GenerateDmarcRecordOptions.


        :param aspf: The aspf of this GenerateDmarcRecordOptions.  # noqa: E501
        :type: str
        """
        allowed_values = ["STRICT", "RELAXED"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and aspf not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `aspf` ({0}), must be one of {1}"  # noqa: E501
                .format(aspf, allowed_values)
            )

        self._aspf = aspf

    @property
    def fo(self):
        """Gets the fo of this GenerateDmarcRecordOptions.  # noqa: E501


        :return: The fo of this GenerateDmarcRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._fo

    @fo.setter
    def fo(self, fo):
        """Sets the fo of this GenerateDmarcRecordOptions.


        :param fo: The fo of this GenerateDmarcRecordOptions.  # noqa: E501
        :type: str
        """
        allowed_values = ["FO_0", "FO_1", "FO_D", "FO_S"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and fo not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `fo` ({0}), must be one of {1}"  # noqa: E501
                .format(fo, allowed_values)
            )

        self._fo = fo

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, GenerateDmarcRecordOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, GenerateDmarcRecordOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/generate_bimi_record_results.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class GenerateBimiRecordResults(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'name': 'str',
        'type': 'str',
        'ttl': 'int',
        'value': 'str'
    }

    attribute_map = {
        'name': 'name',
        'type': 'type',
        'ttl': 'ttl',
        'value': 'value'
    }

    def __init__(self, name=None, type=None, ttl=None, value=None, local_vars_configuration=None):  # noqa: E501
        """GenerateBimiRecordResults - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._name = None
        self._type = None
        self._ttl = None
        self._value = None
        self.discriminator = None

        self.name = name
        self.type = type
        self.ttl = ttl
        self.value = value

    @property
    def name(self):
        """Gets the name of this GenerateBimiRecordResults.  # noqa: E501


        :return: The name of this GenerateBimiRecordResults.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this GenerateBimiRecordResults.


        :param name: The name of this GenerateBimiRecordResults.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    @property
    def type(self):
        """Gets the type of this GenerateBimiRecordResults.  # noqa: E501

        Domain Name Server Record Types  # noqa: E501

        :return: The type of this GenerateBimiRecordResults.  # noqa: E501
        :rtype: str
        """
        return self._type

    @type.setter
    def type(self, type):
        """Sets the type of this GenerateBimiRecordResults.

        Domain Name Server Record Types  # noqa: E501

        :param type: The type of this GenerateBimiRecordResults.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and type is None:  # noqa: E501
            raise ValueError("Invalid value for `type`, must not be `None`")  # noqa: E501
        allowed_values = ["A", "NS", "MD", "MF", "CNAME", "SOA", "MB", "MG", "MR", "NULL", "WKS", "PTR", "HINFO", "MINFO", "MX", "TXT", "RP", "AFSDB", "X25", "ISDN", "RT", "NSAP", "NSAP_PTR", "SIG", "KEY", "PX", "GPOS", "AAAA", "LOC", "NXT", "EID", "NIMLOC", "SRV", "ATMA", "NAPTR", "KX", "CERT", "A6", "DNAME", "SINK", "OPT", "APL", "DS", "SSHFP", "IPSECKEY", "RRSIG", "NSEC", "DNSKEY", "DHCID", "NSEC3", "NSEC3PARAM", "TLSA", "SMIMEA", "HIP", "NINFO", "RKEY", "TALINK", "CDS", "CDNSKEY", "OPENPGPKEY", "CSYNC", "ZONEMD", "SVCB", "HTTPS", "SPF", "UINFO", "UID", "GID", "UNSPEC", "NID", "L32", "L64", "LP", "EUI48", "EUI64", "TKEY", "TSIG", "IXFR", "AXFR", "MAILB", "MAILA", "ANY", "URI", "CAA", "AVC", "DOA", "AMTRELAY", "TA", "DLV"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `type` ({0}), must be one of {1}"  # noqa: E501
                .format(type, allowed_values)
            )

        self._type = type

    @property
    def ttl(self):
        """Gets the ttl of this GenerateBimiRecordResults.  # noqa: E501


        :return: The ttl of this GenerateBimiRecordResults.  # noqa: E501
        :rtype: int
        """
        return self._ttl

    @ttl.setter
    def ttl(self, ttl):
        """Sets the ttl of this GenerateBimiRecordResults.


        :param ttl: The ttl of this GenerateBimiRecordResults.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and ttl is None:  # noqa: E501
            raise ValueError("Invalid value for `ttl`, must not be `None`")  # noqa: E501

        self._ttl = ttl

    @property
    def value(self):
        """Gets the value of this GenerateBimiRecordResults.  # noqa: E501


        :return: The value of this GenerateBimiRecordResults.  # noqa: E501
        :rtype: str
        """
        return self._value

    @value.setter
    def value(self, value):
        """Sets the value of this GenerateBimiRecordResults.


        :param value: The value of this GenerateBimiRecordResults.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and value is None:  # noqa: E501
            raise ValueError("Invalid value for `value`, must not be `None`")  # noqa: E501

        self._value = value

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, GenerateBimiRecordResults):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, GenerateBimiRecordResults):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/generate_bimi_record_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class GenerateBimiRecordOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'domain': 'str',
        'version': 'str',
        'logo_url': 'str',
        'vmc_url': 'str'
    }

    attribute_map = {
        'domain': 'domain',
        'version': 'version',
        'logo_url': 'logoUrl',
        'vmc_url': 'vmcUrl'
    }

    def __init__(self, domain=None, version=None, logo_url=None, vmc_url=None, local_vars_configuration=None):  # noqa: E501
        """GenerateBimiRecordOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._domain = None
        self._version = None
        self._logo_url = None
        self._vmc_url = None
        self.discriminator = None

        self.domain = domain
        self.version = version
        self.logo_url = logo_url
        if vmc_url is not None:
            self.vmc_url = vmc_url

    @property
    def domain(self):
        """Gets the domain of this GenerateBimiRecordOptions.  # noqa: E501


        :return: The domain of this GenerateBimiRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._domain

    @domain.setter
    def domain(self, domain):
        """Sets the domain of this GenerateBimiRecordOptions.


        :param domain: The domain of this GenerateBimiRecordOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and domain is None:  # noqa: E501
            raise ValueError("Invalid value for `domain`, must not be `None`")  # noqa: E501

        self._domain = domain

    @property
    def version(self):
        """Gets the version of this GenerateBimiRecordOptions.  # noqa: E501


        :return: The version of this GenerateBimiRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._version

    @version.setter
    def version(self, version):
        """Sets the version of this GenerateBimiRecordOptions.


        :param version: The version of this GenerateBimiRecordOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and version is None:  # noqa: E501
            raise ValueError("Invalid value for `version`, must not be `None`")  # noqa: E501
        allowed_values = ["BIMI1"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and version not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `version` ({0}), must be one of {1}"  # noqa: E501
                .format(version, allowed_values)
            )

        self._version = version

    @property
    def logo_url(self):
        """Gets the logo_url of this GenerateBimiRecordOptions.  # noqa: E501


        :return: The logo_url of this GenerateBimiRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._logo_url

    @logo_url.setter
    def logo_url(self, logo_url):
        """Sets the logo_url of this GenerateBimiRecordOptions.


        :param logo_url: The logo_url of this GenerateBimiRecordOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and logo_url is None:  # noqa: E501
            raise ValueError("Invalid value for `logo_url`, must not be `None`")  # noqa: E501

        self._logo_url = logo_url

    @property
    def vmc_url(self):
        """Gets the vmc_url of this GenerateBimiRecordOptions.  # noqa: E501


        :return: The vmc_url of this GenerateBimiRecordOptions.  # noqa: E501
        :rtype: str
        """
        return self._vmc_url

    @vmc_url.setter
    def vmc_url(self, vmc_url):
        """Sets the vmc_url of this GenerateBimiRecordOptions.


        :param vmc_url: The vmc_url of this GenerateBimiRecordOptions.  # noqa: E501
        :type: str
        """

        self._vmc_url = vmc_url

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, GenerateBimiRecordOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, GenerateBimiRecordOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/forward_email_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ForwardEmailOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'to': 'list[str]',
        'subject': 'str',
        'cc': 'list[str]',
        'bcc': 'list[str]',
        '_from': 'str',
        'use_inbox_name': 'bool',
        'filter_bounced_recipients': 'bool'
    }

    attribute_map = {
        'to': 'to',
        'subject': 'subject',
        'cc': 'cc',
        'bcc': 'bcc',
        '_from': 'from',
        'use_inbox_name': 'useInboxName',
        'filter_bounced_recipients': 'filterBouncedRecipients'
    }

    def __init__(self, to=None, subject=None, cc=None, bcc=None, _from=None, use_inbox_name=None, filter_bounced_recipients=None, local_vars_configuration=None):  # noqa: E501
        """ForwardEmailOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._to = None
        self._subject = None
        self._cc = None
        self._bcc = None
        self.__from = None
        self._use_inbox_name = None
        self._filter_bounced_recipients = None
        self.discriminator = None

        self.to = to
        self.subject = subject
        self.cc = cc
        self.bcc = bcc
        self._from = _from
        self.use_inbox_name = use_inbox_name
        self.filter_bounced_recipients = filter_bounced_recipients

    @property
    def to(self):
        """Gets the to of this ForwardEmailOptions.  # noqa: E501

        To recipients for forwarded email  # noqa: E501

        :return: The to of this ForwardEmailOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._to

    @to.setter
    def to(self, to):
        """Sets the to of this ForwardEmailOptions.

        To recipients for forwarded email  # noqa: E501

        :param to: The to of this ForwardEmailOptions.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and to is None:  # noqa: E501
            raise ValueError("Invalid value for `to`, must not be `None`")  # noqa: E501

        self._to = to

    @property
    def subject(self):
        """Gets the subject of this ForwardEmailOptions.  # noqa: E501

        Subject for forwarded email  # noqa: E501

        :return: The subject of this ForwardEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this ForwardEmailOptions.

        Subject for forwarded email  # noqa: E501

        :param subject: The subject of this ForwardEmailOptions.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def cc(self):
        """Gets the cc of this ForwardEmailOptions.  # noqa: E501

        Optional cc recipients  # noqa: E501

        :return: The cc of this ForwardEmailOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._cc

    @cc.setter
    def cc(self, cc):
        """Sets the cc of this ForwardEmailOptions.

        Optional cc recipients  # noqa: E501

        :param cc: The cc of this ForwardEmailOptions.  # noqa: E501
        :type: list[str]
        """

        self._cc = cc

    @property
    def bcc(self):
        """Gets the bcc of this ForwardEmailOptions.  # noqa: E501

        Optional bcc recipients  # noqa: E501

        :return: The bcc of this ForwardEmailOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._bcc

    @bcc.setter
    def bcc(self, bcc):
        """Sets the bcc of this ForwardEmailOptions.

        Optional bcc recipients  # noqa: E501

        :param bcc: The bcc of this ForwardEmailOptions.  # noqa: E501
        :type: list[str]
        """

        self._bcc = bcc

    @property
    def _from(self):
        """Gets the _from of this ForwardEmailOptions.  # noqa: E501

        Optional from override  # noqa: E501

        :return: The _from of this ForwardEmailOptions.  # noqa: E501
        :rtype: str
        """
        return self.__from

    @_from.setter
    def _from(self, _from):
        """Sets the _from of this ForwardEmailOptions.

        Optional from override  # noqa: E501

        :param _from: The _from of this ForwardEmailOptions.  # noqa: E501
        :type: str
        """

        self.__from = _from

    @property
    def use_inbox_name(self):
        """Gets the use_inbox_name of this ForwardEmailOptions.  # noqa: E501

        Optionally use inbox name as display name for sender email address  # noqa: E501

        :return: The use_inbox_name of this ForwardEmailOptions.  # noqa: E501
        :rtype: bool
        """
        return self._use_inbox_name

    @use_inbox_name.setter
    def use_inbox_name(self, use_inbox_name):
        """Sets the use_inbox_name of this ForwardEmailOptions.

        Optionally use inbox name as display name for sender email address  # noqa: E501

        :param use_inbox_name: The use_inbox_name of this ForwardEmailOptions.  # noqa: E501
        :type: bool
        """

        self._use_inbox_name = use_inbox_name

    @property
    def filter_bounced_recipients(self):
        """Gets the filter_bounced_recipients of this ForwardEmailOptions.  # noqa: E501

        Filter recipients to remove any bounced recipients from to, bcc, and cc before sending  # noqa: E501

        :return: The filter_bounced_recipients of this ForwardEmailOptions.  # noqa: E501
        :rtype: bool
        """
        return self._filter_bounced_recipients

    @filter_bounced_recipients.setter
    def filter_bounced_recipients(self, filter_bounced_recipients):
        """Sets the filter_bounced_recipients of this ForwardEmailOptions.

        Filter recipients to remove any bounced recipients from to, bcc, and cc before sending  # noqa: E501

        :param filter_bounced_recipients: The filter_bounced_recipients of this ForwardEmailOptions.  # noqa: E501
        :type: bool
        """

        self._filter_bounced_recipients = filter_bounced_recipients

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ForwardEmailOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ForwardEmailOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/flush_expired_inboxes_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class FlushExpiredInboxesResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'inbox_ids': 'list[str]',
        'expire_before': 'datetime'
    }

    attribute_map = {
        'inbox_ids': 'inboxIds',
        'expire_before': 'expireBefore'
    }

    def __init__(self, inbox_ids=None, expire_before=None, local_vars_configuration=None):  # noqa: E501
        """FlushExpiredInboxesResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._inbox_ids = None
        self._expire_before = None
        self.discriminator = None

        self.inbox_ids = inbox_ids
        self.expire_before = expire_before

    @property
    def inbox_ids(self):
        """Gets the inbox_ids of this FlushExpiredInboxesResult.  # noqa: E501

        Inbox IDs affected by expiration  # noqa: E501

        :return: The inbox_ids of this FlushExpiredInboxesResult.  # noqa: E501
        :rtype: list[str]
        """
        return self._inbox_ids

    @inbox_ids.setter
    def inbox_ids(self, inbox_ids):
        """Sets the inbox_ids of this FlushExpiredInboxesResult.

        Inbox IDs affected by expiration  # noqa: E501

        :param inbox_ids: The inbox_ids of this FlushExpiredInboxesResult.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and inbox_ids is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_ids`, must not be `None`")  # noqa: E501

        self._inbox_ids = inbox_ids

    @property
    def expire_before(self):
        """Gets the expire_before of this FlushExpiredInboxesResult.  # noqa: E501

        DateTime to filter inboxes so that those expiring before this time are expired  # noqa: E501

        :return: The expire_before of this FlushExpiredInboxesResult.  # noqa: E501
        :rtype: datetime
        """
        return self._expire_before

    @expire_before.setter
    def expire_before(self, expire_before):
        """Sets the expire_before of this FlushExpiredInboxesResult.

        DateTime to filter inboxes so that those expiring before this time are expired  # noqa: E501

        :param expire_before: The expire_before of this FlushExpiredInboxesResult.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and expire_before is None:  # noqa: E501
            raise ValueError("Invalid value for `expire_before`, must not be `None`")  # noqa: E501

        self._expire_before = expire_before

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, FlushExpiredInboxesResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, FlushExpiredInboxesResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/filter_bounced_recipients_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class FilterBouncedRecipientsResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'filtered_recipients': 'list[str]'
    }

    attribute_map = {
        'filtered_recipients': 'filteredRecipients'
    }

    def __init__(self, filtered_recipients=None, local_vars_configuration=None):  # noqa: E501
        """FilterBouncedRecipientsResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._filtered_recipients = None
        self.discriminator = None

        self.filtered_recipients = filtered_recipients

    @property
    def filtered_recipients(self):
        """Gets the filtered_recipients of this FilterBouncedRecipientsResult.  # noqa: E501


        :return: The filtered_recipients of this FilterBouncedRecipientsResult.  # noqa: E501
        :rtype: list[str]
        """
        return self._filtered_recipients

    @filtered_recipients.setter
    def filtered_recipients(self, filtered_recipients):
        """Sets the filtered_recipients of this FilterBouncedRecipientsResult.


        :param filtered_recipients: The filtered_recipients of this FilterBouncedRecipientsResult.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and filtered_recipients is None:  # noqa: E501
            raise ValueError("Invalid value for `filtered_recipients`, must not be `None`")  # noqa: E501

        self._filtered_recipients = filtered_recipients

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, FilterBouncedRecipientsResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, FilterBouncedRecipientsResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/filter_bounced_recipients_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class FilterBouncedRecipientsOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'email_recipients': 'list[str]'
    }

    attribute_map = {
        'email_recipients': 'emailRecipients'
    }

    def __init__(self, email_recipients=None, local_vars_configuration=None):  # noqa: E501
        """FilterBouncedRecipientsOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._email_recipients = None
        self.discriminator = None

        self.email_recipients = email_recipients

    @property
    def email_recipients(self):
        """Gets the email_recipients of this FilterBouncedRecipientsOptions.  # noqa: E501


        :return: The email_recipients of this FilterBouncedRecipientsOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._email_recipients

    @email_recipients.setter
    def email_recipients(self, email_recipients):
        """Sets the email_recipients of this FilterBouncedRecipientsOptions.


        :param email_recipients: The email_recipients of this FilterBouncedRecipientsOptions.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and email_recipients is None:  # noqa: E501
            raise ValueError("Invalid value for `email_recipients`, must not be `None`")  # noqa: E501

        self._email_recipients = email_recipients

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, FilterBouncedRecipientsOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, FilterBouncedRecipientsOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/fake_email_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class FakeEmailResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'email': 'FakeEmailDto'
    }

    attribute_map = {
        'email': 'email'
    }

    def __init__(self, email=None, local_vars_configuration=None):  # noqa: E501
        """FakeEmailResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._email = None
        self.discriminator = None

        if email is not None:
            self.email = email

    @property
    def email(self):
        """Gets the email of this FakeEmailResult.  # noqa: E501


        :return: The email of this FakeEmailResult.  # noqa: E501
        :rtype: FakeEmailDto
        """
        return self._email

    @email.setter
    def email(self, email):
        """Sets the email of this FakeEmailResult.


        :param email: The email of this FakeEmailResult.  # noqa: E501
        :type: FakeEmailDto
        """

        self._email = email

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, FakeEmailResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, FakeEmailResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/fake_email_preview.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class FakeEmailPreview(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'email_address': 'str',
        'sender': 'Sender',
        'recipients': 'EmailRecipients',
        'subject': 'str',
        'preview': 'str',
        'created_at': 'datetime',
        'seen': 'bool'
    }

    attribute_map = {
        'id': 'id',
        'email_address': 'emailAddress',
        'sender': 'sender',
        'recipients': 'recipients',
        'subject': 'subject',
        'preview': 'preview',
        'created_at': 'createdAt',
        'seen': 'seen'
    }

    def __init__(self, id=None, email_address=None, sender=None, recipients=None, subject=None, preview=None, created_at=None, seen=None, local_vars_configuration=None):  # noqa: E501
        """FakeEmailPreview - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._email_address = None
        self._sender = None
        self._recipients = None
        self._subject = None
        self._preview = None
        self._created_at = None
        self._seen = None
        self.discriminator = None

        self.id = id
        self.email_address = email_address
        self.sender = sender
        self.recipients = recipients
        if subject is not None:
            self.subject = subject
        if preview is not None:
            self.preview = preview
        self.created_at = created_at
        self.seen = seen

    @property
    def id(self):
        """Gets the id of this FakeEmailPreview.  # noqa: E501


        :return: The id of this FakeEmailPreview.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this FakeEmailPreview.


        :param id: The id of this FakeEmailPreview.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def email_address(self):
        """Gets the email_address of this FakeEmailPreview.  # noqa: E501


        :return: The email_address of this FakeEmailPreview.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this FakeEmailPreview.


        :param email_address: The email_address of this FakeEmailPreview.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    @property
    def sender(self):
        """Gets the sender of this FakeEmailPreview.  # noqa: E501


        :return: The sender of this FakeEmailPreview.  # noqa: E501
        :rtype: Sender
        """
        return self._sender

    @sender.setter
    def sender(self, sender):
        """Sets the sender of this FakeEmailPreview.


        :param sender: The sender of this FakeEmailPreview.  # noqa: E501
        :type: Sender
        """

        self._sender = sender

    @property
    def recipients(self):
        """Gets the recipients of this FakeEmailPreview.  # noqa: E501


        :return: The recipients of this FakeEmailPreview.  # noqa: E501
        :rtype: EmailRecipients
        """
        return self._recipients

    @recipients.setter
    def recipients(self, recipients):
        """Sets the recipients of this FakeEmailPreview.


        :param recipients: The recipients of this FakeEmailPreview.  # noqa: E501
        :type: EmailRecipients
        """

        self._recipients = recipients

    @property
    def subject(self):
        """Gets the subject of this FakeEmailPreview.  # noqa: E501


        :return: The subject of this FakeEmailPreview.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this FakeEmailPreview.


        :param subject: The subject of this FakeEmailPreview.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def preview(self):
        """Gets the preview of this FakeEmailPreview.  # noqa: E501


        :return: The preview of this FakeEmailPreview.  # noqa: E501
        :rtype: str
        """
        return self._preview

    @preview.setter
    def preview(self, preview):
        """Sets the preview of this FakeEmailPreview.


        :param preview: The preview of this FakeEmailPreview.  # noqa: E501
        :type: str
        """

        self._preview = preview

    @property
    def created_at(self):
        """Gets the created_at of this FakeEmailPreview.  # noqa: E501


        :return: The created_at of this FakeEmailPreview.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this FakeEmailPreview.


        :param created_at: The created_at of this FakeEmailPreview.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def seen(self):
        """Gets the seen of this FakeEmailPreview.  # noqa: E501


        :return: The seen of this FakeEmailPreview.  # noqa: E501
        :rtype: bool
        """
        return self._seen

    @seen.setter
    def seen(self, seen):
        """Sets the seen of this FakeEmailPreview.


        :param seen: The seen of this FakeEmailPreview.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and seen is None:  # noqa: E501
            raise ValueError("Invalid value for `seen`, must not be `None`")  # noqa: E501

        self._seen = seen

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, FakeEmailPreview):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, FakeEmailPreview):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/fake_email_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class FakeEmailDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'email_address': 'str',
        'sender': 'Sender',
        'recipients': 'EmailRecipients',
        'subject': 'str',
        'preview': 'str',
        'body': 'str',
        'seen': 'bool',
        'created_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'email_address': 'emailAddress',
        'sender': 'sender',
        'recipients': 'recipients',
        'subject': 'subject',
        'preview': 'preview',
        'body': 'body',
        'seen': 'seen',
        'created_at': 'createdAt'
    }

    def __init__(self, id=None, email_address=None, sender=None, recipients=None, subject=None, preview=None, body=None, seen=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """FakeEmailDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._email_address = None
        self._sender = None
        self._recipients = None
        self._subject = None
        self._preview = None
        self._body = None
        self._seen = None
        self._created_at = None
        self.discriminator = None

        self.id = id
        self.email_address = email_address
        self.sender = sender
        self.recipients = recipients
        if subject is not None:
            self.subject = subject
        if preview is not None:
            self.preview = preview
        self.body = body
        self.seen = seen
        self.created_at = created_at

    @property
    def id(self):
        """Gets the id of this FakeEmailDto.  # noqa: E501


        :return: The id of this FakeEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this FakeEmailDto.


        :param id: The id of this FakeEmailDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def email_address(self):
        """Gets the email_address of this FakeEmailDto.  # noqa: E501


        :return: The email_address of this FakeEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this FakeEmailDto.


        :param email_address: The email_address of this FakeEmailDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    @property
    def sender(self):
        """Gets the sender of this FakeEmailDto.  # noqa: E501


        :return: The sender of this FakeEmailDto.  # noqa: E501
        :rtype: Sender
        """
        return self._sender

    @sender.setter
    def sender(self, sender):
        """Sets the sender of this FakeEmailDto.


        :param sender: The sender of this FakeEmailDto.  # noqa: E501
        :type: Sender
        """

        self._sender = sender

    @property
    def recipients(self):
        """Gets the recipients of this FakeEmailDto.  # noqa: E501


        :return: The recipients of this FakeEmailDto.  # noqa: E501
        :rtype: EmailRecipients
        """
        return self._recipients

    @recipients.setter
    def recipients(self, recipients):
        """Sets the recipients of this FakeEmailDto.


        :param recipients: The recipients of this FakeEmailDto.  # noqa: E501
        :type: EmailRecipients
        """

        self._recipients = recipients

    @property
    def subject(self):
        """Gets the subject of this FakeEmailDto.  # noqa: E501


        :return: The subject of this FakeEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this FakeEmailDto.


        :param subject: The subject of this FakeEmailDto.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def preview(self):
        """Gets the preview of this FakeEmailDto.  # noqa: E501


        :return: The preview of this FakeEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._preview

    @preview.setter
    def preview(self, preview):
        """Sets the preview of this FakeEmailDto.


        :param preview: The preview of this FakeEmailDto.  # noqa: E501
        :type: str
        """

        self._preview = preview

    @property
    def body(self):
        """Gets the body of this FakeEmailDto.  # noqa: E501


        :return: The body of this FakeEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this FakeEmailDto.


        :param body: The body of this FakeEmailDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and body is None:  # noqa: E501
            raise ValueError("Invalid value for `body`, must not be `None`")  # noqa: E501

        self._body = body

    @property
    def seen(self):
        """Gets the seen of this FakeEmailDto.  # noqa: E501


        :return: The seen of this FakeEmailDto.  # noqa: E501
        :rtype: bool
        """
        return self._seen

    @seen.setter
    def seen(self, seen):
        """Sets the seen of this FakeEmailDto.


        :param seen: The seen of this FakeEmailDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and seen is None:  # noqa: E501
            raise ValueError("Invalid value for `seen`, must not be `None`")  # noqa: E501

        self._seen = seen

    @property
    def created_at(self):
        """Gets the created_at of this FakeEmailDto.  # noqa: E501


        :return: The created_at of this FakeEmailDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this FakeEmailDto.


        :param created_at: The created_at of this FakeEmailDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, FakeEmailDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, FakeEmailDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/export_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ExportOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'output_format': 'str',
        'exclude_previously_exported': 'bool',
        'created_earliest_time': 'datetime',
        'created_oldest_time': 'datetime',
        'filter': 'str',
        'list_separator_token': 'str'
    }

    attribute_map = {
        'output_format': 'outputFormat',
        'exclude_previously_exported': 'excludePreviouslyExported',
        'created_earliest_time': 'createdEarliestTime',
        'created_oldest_time': 'createdOldestTime',
        'filter': 'filter',
        'list_separator_token': 'listSeparatorToken'
    }

    def __init__(self, output_format=None, exclude_previously_exported=None, created_earliest_time=None, created_oldest_time=None, filter=None, list_separator_token=None, local_vars_configuration=None):  # noqa: E501
        """ExportOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._output_format = None
        self._exclude_previously_exported = None
        self._created_earliest_time = None
        self._created_oldest_time = None
        self._filter = None
        self._list_separator_token = None
        self.discriminator = None

        self.output_format = output_format
        self.exclude_previously_exported = exclude_previously_exported
        self.created_earliest_time = created_earliest_time
        self.created_oldest_time = created_oldest_time
        self.filter = filter
        self.list_separator_token = list_separator_token

    @property
    def output_format(self):
        """Gets the output_format of this ExportOptions.  # noqa: E501


        :return: The output_format of this ExportOptions.  # noqa: E501
        :rtype: str
        """
        return self._output_format

    @output_format.setter
    def output_format(self, output_format):
        """Sets the output_format of this ExportOptions.


        :param output_format: The output_format of this ExportOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and output_format is None:  # noqa: E501
            raise ValueError("Invalid value for `output_format`, must not be `None`")  # noqa: E501
        allowed_values = ["CSV_DEFAULT", "CSV_EXCEL"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and output_format not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `output_format` ({0}), must be one of {1}"  # noqa: E501
                .format(output_format, allowed_values)
            )

        self._output_format = output_format

    @property
    def exclude_previously_exported(self):
        """Gets the exclude_previously_exported of this ExportOptions.  # noqa: E501


        :return: The exclude_previously_exported of this ExportOptions.  # noqa: E501
        :rtype: bool
        """
        return self._exclude_previously_exported

    @exclude_previously_exported.setter
    def exclude_previously_exported(self, exclude_previously_exported):
        """Sets the exclude_previously_exported of this ExportOptions.


        :param exclude_previously_exported: The exclude_previously_exported of this ExportOptions.  # noqa: E501
        :type: bool
        """

        self._exclude_previously_exported = exclude_previously_exported

    @property
    def created_earliest_time(self):
        """Gets the created_earliest_time of this ExportOptions.  # noqa: E501


        :return: The created_earliest_time of this ExportOptions.  # noqa: E501
        :rtype: datetime
        """
        return self._created_earliest_time

    @created_earliest_time.setter
    def created_earliest_time(self, created_earliest_time):
        """Sets the created_earliest_time of this ExportOptions.


        :param created_earliest_time: The created_earliest_time of this ExportOptions.  # noqa: E501
        :type: datetime
        """

        self._created_earliest_time = created_earliest_time

    @property
    def created_oldest_time(self):
        """Gets the created_oldest_time of this ExportOptions.  # noqa: E501


        :return: The created_oldest_time of this ExportOptions.  # noqa: E501
        :rtype: datetime
        """
        return self._created_oldest_time

    @created_oldest_time.setter
    def created_oldest_time(self, created_oldest_time):
        """Sets the created_oldest_time of this ExportOptions.


        :param created_oldest_time: The created_oldest_time of this ExportOptions.  # noqa: E501
        :type: datetime
        """

        self._created_oldest_time = created_oldest_time

    @property
    def filter(self):
        """Gets the filter of this ExportOptions.  # noqa: E501


        :return: The filter of this ExportOptions.  # noqa: E501
        :rtype: str
        """
        return self._filter

    @filter.setter
    def filter(self, filter):
        """Sets the filter of this ExportOptions.


        :param filter: The filter of this ExportOptions.  # noqa: E501
        :type: str
        """

        self._filter = filter

    @property
    def list_separator_token(self):
        """Gets the list_separator_token of this ExportOptions.  # noqa: E501


        :return: The list_separator_token of this ExportOptions.  # noqa: E501
        :rtype: str
        """
        return self._list_separator_token

    @list_separator_token.setter
    def list_separator_token(self, list_separator_token):
        """Sets the list_separator_token of this ExportOptions.


        :param list_separator_token: The list_separator_token of this ExportOptions.  # noqa: E501
        :type: str
        """

        self._list_separator_token = list_separator_token

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ExportOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ExportOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/export_link.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ExportLink(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'download_link': 'str'
    }

    attribute_map = {
        'download_link': 'downloadLink'
    }

    def __init__(self, download_link=None, local_vars_configuration=None):  # noqa: E501
        """ExportLink - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._download_link = None
        self.discriminator = None

        self.download_link = download_link

    @property
    def download_link(self):
        """Gets the download_link of this ExportLink.  # noqa: E501


        :return: The download_link of this ExportLink.  # noqa: E501
        :rtype: str
        """
        return self._download_link

    @download_link.setter
    def download_link(self, download_link):
        """Sets the download_link of this ExportLink.


        :param download_link: The download_link of this ExportLink.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and download_link is None:  # noqa: E501
            raise ValueError("Invalid value for `download_link`, must not be `None`")  # noqa: E501

        self._download_link = download_link

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ExportLink):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ExportLink):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/expired_inbox_record_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ExpiredInboxRecordProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'email_address': 'str',
        'user_id': 'str',
        'id': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'email_address': 'emailAddress',
        'user_id': 'userId',
        'id': 'id'
    }

    def __init__(self, created_at=None, email_address=None, user_id=None, id=None, local_vars_configuration=None):  # noqa: E501
        """ExpiredInboxRecordProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._email_address = None
        self._user_id = None
        self._id = None
        self.discriminator = None

        self.created_at = created_at
        self.email_address = email_address
        self.user_id = user_id
        self.id = id

    @property
    def created_at(self):
        """Gets the created_at of this ExpiredInboxRecordProjection.  # noqa: E501


        :return: The created_at of this ExpiredInboxRecordProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this ExpiredInboxRecordProjection.


        :param created_at: The created_at of this ExpiredInboxRecordProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def email_address(self):
        """Gets the email_address of this ExpiredInboxRecordProjection.  # noqa: E501


        :return: The email_address of this ExpiredInboxRecordProjection.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this ExpiredInboxRecordProjection.


        :param email_address: The email_address of this ExpiredInboxRecordProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    @property
    def user_id(self):
        """Gets the user_id of this ExpiredInboxRecordProjection.  # noqa: E501


        :return: The user_id of this ExpiredInboxRecordProjection.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this ExpiredInboxRecordProjection.


        :param user_id: The user_id of this ExpiredInboxRecordProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def id(self):
        """Gets the id of this ExpiredInboxRecordProjection.  # noqa: E501


        :return: The id of this ExpiredInboxRecordProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this ExpiredInboxRecordProjection.


        :param id: The id of this ExpiredInboxRecordProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ExpiredInboxRecordProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ExpiredInboxRecordProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/expired_inbox_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ExpiredInboxDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'inbox_id': 'str',
        'email_address': 'str'
    }

    attribute_map = {
        'id': 'id',
        'inbox_id': 'inboxId',
        'email_address': 'emailAddress'
    }

    def __init__(self, id=None, inbox_id=None, email_address=None, local_vars_configuration=None):  # noqa: E501
        """ExpiredInboxDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._inbox_id = None
        self._email_address = None
        self.discriminator = None

        self.id = id
        self.inbox_id = inbox_id
        self.email_address = email_address

    @property
    def id(self):
        """Gets the id of this ExpiredInboxDto.  # noqa: E501


        :return: The id of this ExpiredInboxDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this ExpiredInboxDto.


        :param id: The id of this ExpiredInboxDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def inbox_id(self):
        """Gets the inbox_id of this ExpiredInboxDto.  # noqa: E501


        :return: The inbox_id of this ExpiredInboxDto.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this ExpiredInboxDto.


        :param inbox_id: The inbox_id of this ExpiredInboxDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def email_address(self):
        """Gets the email_address of this ExpiredInboxDto.  # noqa: E501


        :return: The email_address of this ExpiredInboxDto.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this ExpiredInboxDto.


        :param email_address: The email_address of this ExpiredInboxDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ExpiredInboxDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ExpiredInboxDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/expiration_defaults.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ExpirationDefaults(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'default_expiration_millis': 'int',
        'max_expiration_millis': 'int',
        'default_expires_at': 'datetime',
        'can_permanent_inbox': 'bool',
        'next_inbox_allows_permanent': 'bool'
    }

    attribute_map = {
        'default_expiration_millis': 'defaultExpirationMillis',
        'max_expiration_millis': 'maxExpirationMillis',
        'default_expires_at': 'defaultExpiresAt',
        'can_permanent_inbox': 'canPermanentInbox',
        'next_inbox_allows_permanent': 'nextInboxAllowsPermanent'
    }

    def __init__(self, default_expiration_millis=None, max_expiration_millis=None, default_expires_at=None, can_permanent_inbox=None, next_inbox_allows_permanent=None, local_vars_configuration=None):  # noqa: E501
        """ExpirationDefaults - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._default_expiration_millis = None
        self._max_expiration_millis = None
        self._default_expires_at = None
        self._can_permanent_inbox = None
        self._next_inbox_allows_permanent = None
        self.discriminator = None

        self.default_expiration_millis = default_expiration_millis
        self.max_expiration_millis = max_expiration_millis
        self.default_expires_at = default_expires_at
        self.can_permanent_inbox = can_permanent_inbox
        self.next_inbox_allows_permanent = next_inbox_allows_permanent

    @property
    def default_expiration_millis(self):
        """Gets the default_expiration_millis of this ExpirationDefaults.  # noqa: E501


        :return: The default_expiration_millis of this ExpirationDefaults.  # noqa: E501
        :rtype: int
        """
        return self._default_expiration_millis

    @default_expiration_millis.setter
    def default_expiration_millis(self, default_expiration_millis):
        """Sets the default_expiration_millis of this ExpirationDefaults.


        :param default_expiration_millis: The default_expiration_millis of this ExpirationDefaults.  # noqa: E501
        :type: int
        """

        self._default_expiration_millis = default_expiration_millis

    @property
    def max_expiration_millis(self):
        """Gets the max_expiration_millis of this ExpirationDefaults.  # noqa: E501


        :return: The max_expiration_millis of this ExpirationDefaults.  # noqa: E501
        :rtype: int
        """
        return self._max_expiration_millis

    @max_expiration_millis.setter
    def max_expiration_millis(self, max_expiration_millis):
        """Sets the max_expiration_millis of this ExpirationDefaults.


        :param max_expiration_millis: The max_expiration_millis of this ExpirationDefaults.  # noqa: E501
        :type: int
        """

        self._max_expiration_millis = max_expiration_millis

    @property
    def default_expires_at(self):
        """Gets the default_expires_at of this ExpirationDefaults.  # noqa: E501


        :return: The default_expires_at of this ExpirationDefaults.  # noqa: E501
        :rtype: datetime
        """
        return self._default_expires_at

    @default_expires_at.setter
    def default_expires_at(self, default_expires_at):
        """Sets the default_expires_at of this ExpirationDefaults.


        :param default_expires_at: The default_expires_at of this ExpirationDefaults.  # noqa: E501
        :type: datetime
        """

        self._default_expires_at = default_expires_at

    @property
    def can_permanent_inbox(self):
        """Gets the can_permanent_inbox of this ExpirationDefaults.  # noqa: E501


        :return: The can_permanent_inbox of this ExpirationDefaults.  # noqa: E501
        :rtype: bool
        """
        return self._can_permanent_inbox

    @can_permanent_inbox.setter
    def can_permanent_inbox(self, can_permanent_inbox):
        """Sets the can_permanent_inbox of this ExpirationDefaults.


        :param can_permanent_inbox: The can_permanent_inbox of this ExpirationDefaults.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and can_permanent_inbox is None:  # noqa: E501
            raise ValueError("Invalid value for `can_permanent_inbox`, must not be `None`")  # noqa: E501

        self._can_permanent_inbox = can_permanent_inbox

    @property
    def next_inbox_allows_permanent(self):
        """Gets the next_inbox_allows_permanent of this ExpirationDefaults.  # noqa: E501


        :return: The next_inbox_allows_permanent of this ExpirationDefaults.  # noqa: E501
        :rtype: bool
        """
        return self._next_inbox_allows_permanent

    @next_inbox_allows_permanent.setter
    def next_inbox_allows_permanent(self, next_inbox_allows_permanent):
        """Sets the next_inbox_allows_permanent of this ExpirationDefaults.


        :param next_inbox_allows_permanent: The next_inbox_allows_permanent of this ExpirationDefaults.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and next_inbox_allows_permanent is None:  # noqa: E501
            raise ValueError("Invalid value for `next_inbox_allows_permanent`, must not be `None`")  # noqa: E501

        self._next_inbox_allows_permanent = next_inbox_allows_permanent

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ExpirationDefaults):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ExpirationDefaults):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/empty_response_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmptyResponseDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'message': 'str'
    }

    attribute_map = {
        'message': 'message'
    }

    def __init__(self, message=None, local_vars_configuration=None):  # noqa: E501
        """EmptyResponseDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._message = None
        self.discriminator = None

        if message is not None:
            self.message = message

    @property
    def message(self):
        """Gets the message of this EmptyResponseDto.  # noqa: E501


        :return: The message of this EmptyResponseDto.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this EmptyResponseDto.


        :param message: The message of this EmptyResponseDto.  # noqa: E501
        :type: str
        """

        self._message = message

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmptyResponseDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmptyResponseDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/emergency_address_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmergencyAddressDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'address1': 'str',
        'phone_country': 'str'
    }

    attribute_map = {
        'id': 'id',
        'address1': 'address1',
        'phone_country': 'phoneCountry'
    }

    def __init__(self, id=None, address1=None, phone_country=None, local_vars_configuration=None):  # noqa: E501
        """EmergencyAddressDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._address1 = None
        self._phone_country = None
        self.discriminator = None

        self.id = id
        self.address1 = address1
        self.phone_country = phone_country

    @property
    def id(self):
        """Gets the id of this EmergencyAddressDto.  # noqa: E501


        :return: The id of this EmergencyAddressDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this EmergencyAddressDto.


        :param id: The id of this EmergencyAddressDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def address1(self):
        """Gets the address1 of this EmergencyAddressDto.  # noqa: E501


        :return: The address1 of this EmergencyAddressDto.  # noqa: E501
        :rtype: str
        """
        return self._address1

    @address1.setter
    def address1(self, address1):
        """Sets the address1 of this EmergencyAddressDto.


        :param address1: The address1 of this EmergencyAddressDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and address1 is None:  # noqa: E501
            raise ValueError("Invalid value for `address1`, must not be `None`")  # noqa: E501

        self._address1 = address1

    @property
    def phone_country(self):
        """Gets the phone_country of this EmergencyAddressDto.  # noqa: E501


        :return: The phone_country of this EmergencyAddressDto.  # noqa: E501
        :rtype: str
        """
        return self._phone_country

    @phone_country.setter
    def phone_country(self, phone_country):
        """Sets the phone_country of this EmergencyAddressDto.


        :param phone_country: The phone_country of this EmergencyAddressDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and phone_country is None:  # noqa: E501
            raise ValueError("Invalid value for `phone_country`, must not be `None`")  # noqa: E501
        allowed_values = ["US", "GB", "AU"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and phone_country not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `phone_country` ({0}), must be one of {1}"  # noqa: E501
                .format(phone_country, allowed_values)
            )

        self._phone_country = phone_country

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmergencyAddressDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmergencyAddressDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/emergency_address.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmergencyAddress(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'sid': 'str',
        'user_id': 'str',
        'display_name': 'str',
        'customer_name': 'str',
        'address1': 'str',
        'city': 'str',
        'region': 'str',
        'postal_code': 'str',
        'phone_country': 'str',
        'account_sid': 'str',
        'created_at': 'datetime',
        'updated_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'sid': 'sid',
        'user_id': 'userId',
        'display_name': 'displayName',
        'customer_name': 'customerName',
        'address1': 'address1',
        'city': 'city',
        'region': 'region',
        'postal_code': 'postalCode',
        'phone_country': 'phoneCountry',
        'account_sid': 'accountSid',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt'
    }

    def __init__(self, id=None, sid=None, user_id=None, display_name=None, customer_name=None, address1=None, city=None, region=None, postal_code=None, phone_country=None, account_sid=None, created_at=None, updated_at=None, local_vars_configuration=None):  # noqa: E501
        """EmergencyAddress - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._sid = None
        self._user_id = None
        self._display_name = None
        self._customer_name = None
        self._address1 = None
        self._city = None
        self._region = None
        self._postal_code = None
        self._phone_country = None
        self._account_sid = None
        self._created_at = None
        self._updated_at = None
        self.discriminator = None

        if id is not None:
            self.id = id
        self.sid = sid
        self.user_id = user_id
        self.display_name = display_name
        self.customer_name = customer_name
        self.address1 = address1
        self.city = city
        self.region = region
        self.postal_code = postal_code
        self.phone_country = phone_country
        self.account_sid = account_sid
        self.created_at = created_at
        self.updated_at = updated_at

    @property
    def id(self):
        """Gets the id of this EmergencyAddress.  # noqa: E501


        :return: The id of this EmergencyAddress.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this EmergencyAddress.


        :param id: The id of this EmergencyAddress.  # noqa: E501
        :type: str
        """

        self._id = id

    @property
    def sid(self):
        """Gets the sid of this EmergencyAddress.  # noqa: E501


        :return: The sid of this EmergencyAddress.  # noqa: E501
        :rtype: str
        """
        return self._sid

    @sid.setter
    def sid(self, sid):
        """Sets the sid of this EmergencyAddress.


        :param sid: The sid of this EmergencyAddress.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and sid is None:  # noqa: E501
            raise ValueError("Invalid value for `sid`, must not be `None`")  # noqa: E501

        self._sid = sid

    @property
    def user_id(self):
        """Gets the user_id of this EmergencyAddress.  # noqa: E501


        :return: The user_id of this EmergencyAddress.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this EmergencyAddress.


        :param user_id: The user_id of this EmergencyAddress.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def display_name(self):
        """Gets the display_name of this EmergencyAddress.  # noqa: E501


        :return: The display_name of this EmergencyAddress.  # noqa: E501
        :rtype: str
        """
        return self._display_name

    @display_name.setter
    def display_name(self, display_name):
        """Sets the display_name of this EmergencyAddress.


        :param display_name: The display_name of this EmergencyAddress.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and display_name is None:  # noqa: E501
            raise ValueError("Invalid value for `display_name`, must not be `None`")  # noqa: E501

        self._display_name = display_name

    @property
    def customer_name(self):
        """Gets the customer_name of this EmergencyAddress.  # noqa: E501


        :return: The customer_name of this EmergencyAddress.  # noqa: E501
        :rtype: str
        """
        return self._customer_name

    @customer_name.setter
    def customer_name(self, customer_name):
        """Sets the customer_name of this EmergencyAddress.


        :param customer_name: The customer_name of this EmergencyAddress.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and customer_name is None:  # noqa: E501
            raise ValueError("Invalid value for `customer_name`, must not be `None`")  # noqa: E501

        self._customer_name = customer_name

    @property
    def address1(self):
        """Gets the address1 of this EmergencyAddress.  # noqa: E501


        :return: The address1 of this EmergencyAddress.  # noqa: E501
        :rtype: str
        """
        return self._address1

    @address1.setter
    def address1(self, address1):
        """Sets the address1 of this EmergencyAddress.


        :param address1: The address1 of this EmergencyAddress.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and address1 is None:  # noqa: E501
            raise ValueError("Invalid value for `address1`, must not be `None`")  # noqa: E501

        self._address1 = address1

    @property
    def city(self):
        """Gets the city of this EmergencyAddress.  # noqa: E501


        :return: The city of this EmergencyAddress.  # noqa: E501
        :rtype: str
        """
        return self._city

    @city.setter
    def city(self, city):
        """Sets the city of this EmergencyAddress.


        :param city: The city of this EmergencyAddress.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and city is None:  # noqa: E501
            raise ValueError("Invalid value for `city`, must not be `None`")  # noqa: E501

        self._city = city

    @property
    def region(self):
        """Gets the region of this EmergencyAddress.  # noqa: E501


        :return: The region of this EmergencyAddress.  # noqa: E501
        :rtype: str
        """
        return self._region

    @region.setter
    def region(self, region):
        """Sets the region of this EmergencyAddress.


        :param region: The region of this EmergencyAddress.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and region is None:  # noqa: E501
            raise ValueError("Invalid value for `region`, must not be `None`")  # noqa: E501

        self._region = region

    @property
    def postal_code(self):
        """Gets the postal_code of this EmergencyAddress.  # noqa: E501


        :return: The postal_code of this EmergencyAddress.  # noqa: E501
        :rtype: str
        """
        return self._postal_code

    @postal_code.setter
    def postal_code(self, postal_code):
        """Sets the postal_code of this EmergencyAddress.


        :param postal_code: The postal_code of this EmergencyAddress.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and postal_code is None:  # noqa: E501
            raise ValueError("Invalid value for `postal_code`, must not be `None`")  # noqa: E501

        self._postal_code = postal_code

    @property
    def phone_country(self):
        """Gets the phone_country of this EmergencyAddress.  # noqa: E501


        :return: The phone_country of this EmergencyAddress.  # noqa: E501
        :rtype: str
        """
        return self._phone_country

    @phone_country.setter
    def phone_country(self, phone_country):
        """Sets the phone_country of this EmergencyAddress.


        :param phone_country: The phone_country of this EmergencyAddress.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and phone_country is None:  # noqa: E501
            raise ValueError("Invalid value for `phone_country`, must not be `None`")  # noqa: E501
        allowed_values = ["US", "GB", "AU"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and phone_country not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `phone_country` ({0}), must be one of {1}"  # noqa: E501
                .format(phone_country, allowed_values)
            )

        self._phone_country = phone_country

    @property
    def account_sid(self):
        """Gets the account_sid of this EmergencyAddress.  # noqa: E501


        :return: The account_sid of this EmergencyAddress.  # noqa: E501
        :rtype: str
        """
        return self._account_sid

    @account_sid.setter
    def account_sid(self, account_sid):
        """Sets the account_sid of this EmergencyAddress.


        :param account_sid: The account_sid of this EmergencyAddress.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and account_sid is None:  # noqa: E501
            raise ValueError("Invalid value for `account_sid`, must not be `None`")  # noqa: E501

        self._account_sid = account_sid

    @property
    def created_at(self):
        """Gets the created_at of this EmergencyAddress.  # noqa: E501


        :return: The created_at of this EmergencyAddress.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this EmergencyAddress.


        :param created_at: The created_at of this EmergencyAddress.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this EmergencyAddress.  # noqa: E501


        :return: The updated_at of this EmergencyAddress.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this EmergencyAddress.


        :param updated_at: The updated_at of this EmergencyAddress.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmergencyAddress):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmergencyAddress):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_verification_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailVerificationResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'domain_name': 'str',
        'port': 'int',
        'email_address': 'str',
        'is_valid': 'bool',
        'error': 'str'
    }

    attribute_map = {
        'domain_name': 'domainName',
        'port': 'port',
        'email_address': 'emailAddress',
        'is_valid': 'isValid',
        'error': 'error'
    }

    def __init__(self, domain_name=None, port=None, email_address=None, is_valid=None, error=None, local_vars_configuration=None):  # noqa: E501
        """EmailVerificationResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._domain_name = None
        self._port = None
        self._email_address = None
        self._is_valid = None
        self._error = None
        self.discriminator = None

        self.domain_name = domain_name
        self.port = port
        self.email_address = email_address
        self.is_valid = is_valid
        self.error = error

    @property
    def domain_name(self):
        """Gets the domain_name of this EmailVerificationResult.  # noqa: E501


        :return: The domain_name of this EmailVerificationResult.  # noqa: E501
        :rtype: str
        """
        return self._domain_name

    @domain_name.setter
    def domain_name(self, domain_name):
        """Sets the domain_name of this EmailVerificationResult.


        :param domain_name: The domain_name of this EmailVerificationResult.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and domain_name is None:  # noqa: E501
            raise ValueError("Invalid value for `domain_name`, must not be `None`")  # noqa: E501

        self._domain_name = domain_name

    @property
    def port(self):
        """Gets the port of this EmailVerificationResult.  # noqa: E501


        :return: The port of this EmailVerificationResult.  # noqa: E501
        :rtype: int
        """
        return self._port

    @port.setter
    def port(self, port):
        """Sets the port of this EmailVerificationResult.


        :param port: The port of this EmailVerificationResult.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and port is None:  # noqa: E501
            raise ValueError("Invalid value for `port`, must not be `None`")  # noqa: E501

        self._port = port

    @property
    def email_address(self):
        """Gets the email_address of this EmailVerificationResult.  # noqa: E501


        :return: The email_address of this EmailVerificationResult.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this EmailVerificationResult.


        :param email_address: The email_address of this EmailVerificationResult.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    @property
    def is_valid(self):
        """Gets the is_valid of this EmailVerificationResult.  # noqa: E501


        :return: The is_valid of this EmailVerificationResult.  # noqa: E501
        :rtype: bool
        """
        return self._is_valid

    @is_valid.setter
    def is_valid(self, is_valid):
        """Sets the is_valid of this EmailVerificationResult.


        :param is_valid: The is_valid of this EmailVerificationResult.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and is_valid is None:  # noqa: E501
            raise ValueError("Invalid value for `is_valid`, must not be `None`")  # noqa: E501

        self._is_valid = is_valid

    @property
    def error(self):
        """Gets the error of this EmailVerificationResult.  # noqa: E501


        :return: The error of this EmailVerificationResult.  # noqa: E501
        :rtype: str
        """
        return self._error

    @error.setter
    def error(self, error):
        """Sets the error of this EmailVerificationResult.


        :param error: The error of this EmailVerificationResult.  # noqa: E501
        :type: str
        """

        self._error = error

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailVerificationResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailVerificationResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_validation_request_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailValidationRequestDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'email_address': 'str',
        'is_valid': 'bool',
        'created_at': 'datetime',
        'updated_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'email_address': 'emailAddress',
        'is_valid': 'isValid',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt'
    }

    def __init__(self, id=None, user_id=None, email_address=None, is_valid=None, created_at=None, updated_at=None, local_vars_configuration=None):  # noqa: E501
        """EmailValidationRequestDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._email_address = None
        self._is_valid = None
        self._created_at = None
        self._updated_at = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        self.email_address = email_address
        self.is_valid = is_valid
        self.created_at = created_at
        self.updated_at = updated_at

    @property
    def id(self):
        """Gets the id of this EmailValidationRequestDto.  # noqa: E501


        :return: The id of this EmailValidationRequestDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this EmailValidationRequestDto.


        :param id: The id of this EmailValidationRequestDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this EmailValidationRequestDto.  # noqa: E501


        :return: The user_id of this EmailValidationRequestDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this EmailValidationRequestDto.


        :param user_id: The user_id of this EmailValidationRequestDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def email_address(self):
        """Gets the email_address of this EmailValidationRequestDto.  # noqa: E501


        :return: The email_address of this EmailValidationRequestDto.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this EmailValidationRequestDto.


        :param email_address: The email_address of this EmailValidationRequestDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    @property
    def is_valid(self):
        """Gets the is_valid of this EmailValidationRequestDto.  # noqa: E501


        :return: The is_valid of this EmailValidationRequestDto.  # noqa: E501
        :rtype: bool
        """
        return self._is_valid

    @is_valid.setter
    def is_valid(self, is_valid):
        """Sets the is_valid of this EmailValidationRequestDto.


        :param is_valid: The is_valid of this EmailValidationRequestDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and is_valid is None:  # noqa: E501
            raise ValueError("Invalid value for `is_valid`, must not be `None`")  # noqa: E501

        self._is_valid = is_valid

    @property
    def created_at(self):
        """Gets the created_at of this EmailValidationRequestDto.  # noqa: E501


        :return: The created_at of this EmailValidationRequestDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this EmailValidationRequestDto.


        :param created_at: The created_at of this EmailValidationRequestDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this EmailValidationRequestDto.  # noqa: E501


        :return: The updated_at of this EmailValidationRequestDto.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this EmailValidationRequestDto.


        :param updated_at: The updated_at of this EmailValidationRequestDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailValidationRequestDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailValidationRequestDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_text_lines_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailTextLinesResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'lines': 'list[str]',
        'body': 'str'
    }

    attribute_map = {
        'lines': 'lines',
        'body': 'body'
    }

    def __init__(self, lines=None, body=None, local_vars_configuration=None):  # noqa: E501
        """EmailTextLinesResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._lines = None
        self._body = None
        self.discriminator = None

        self.lines = lines
        self.body = body

    @property
    def lines(self):
        """Gets the lines of this EmailTextLinesResult.  # noqa: E501


        :return: The lines of this EmailTextLinesResult.  # noqa: E501
        :rtype: list[str]
        """
        return self._lines

    @lines.setter
    def lines(self, lines):
        """Sets the lines of this EmailTextLinesResult.


        :param lines: The lines of this EmailTextLinesResult.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and lines is None:  # noqa: E501
            raise ValueError("Invalid value for `lines`, must not be `None`")  # noqa: E501

        self._lines = lines

    @property
    def body(self):
        """Gets the body of this EmailTextLinesResult.  # noqa: E501


        :return: The body of this EmailTextLinesResult.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this EmailTextLinesResult.


        :param body: The body of this EmailTextLinesResult.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and body is None:  # noqa: E501
            raise ValueError("Invalid value for `body`, must not be `None`")  # noqa: E501

        self._body = body

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailTextLinesResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailTextLinesResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_screenshot_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailScreenshotResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'base64_encoded_image': 'str'
    }

    attribute_map = {
        'base64_encoded_image': 'base64EncodedImage'
    }

    def __init__(self, base64_encoded_image=None, local_vars_configuration=None):  # noqa: E501
        """EmailScreenshotResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._base64_encoded_image = None
        self.discriminator = None

        self.base64_encoded_image = base64_encoded_image

    @property
    def base64_encoded_image(self):
        """Gets the base64_encoded_image of this EmailScreenshotResult.  # noqa: E501


        :return: The base64_encoded_image of this EmailScreenshotResult.  # noqa: E501
        :rtype: str
        """
        return self._base64_encoded_image

    @base64_encoded_image.setter
    def base64_encoded_image(self, base64_encoded_image):
        """Sets the base64_encoded_image of this EmailScreenshotResult.


        :param base64_encoded_image: The base64_encoded_image of this EmailScreenshotResult.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and base64_encoded_image is None:  # noqa: E501
            raise ValueError("Invalid value for `base64_encoded_image`, must not be `None`")  # noqa: E501

        self._base64_encoded_image = base64_encoded_image

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailScreenshotResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailScreenshotResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_recipients.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailRecipients(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'to': 'list[Recipient]',
        'cc': 'list[Recipient]',
        'bcc': 'list[Recipient]'
    }

    attribute_map = {
        'to': 'to',
        'cc': 'cc',
        'bcc': 'bcc'
    }

    def __init__(self, to=None, cc=None, bcc=None, local_vars_configuration=None):  # noqa: E501
        """EmailRecipients - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._to = None
        self._cc = None
        self._bcc = None
        self.discriminator = None

        if to is not None:
            self.to = to
        if cc is not None:
            self.cc = cc
        if bcc is not None:
            self.bcc = bcc

    @property
    def to(self):
        """Gets the to of this EmailRecipients.  # noqa: E501


        :return: The to of this EmailRecipients.  # noqa: E501
        :rtype: list[Recipient]
        """
        return self._to

    @to.setter
    def to(self, to):
        """Sets the to of this EmailRecipients.


        :param to: The to of this EmailRecipients.  # noqa: E501
        :type: list[Recipient]
        """

        self._to = to

    @property
    def cc(self):
        """Gets the cc of this EmailRecipients.  # noqa: E501


        :return: The cc of this EmailRecipients.  # noqa: E501
        :rtype: list[Recipient]
        """
        return self._cc

    @cc.setter
    def cc(self, cc):
        """Sets the cc of this EmailRecipients.


        :param cc: The cc of this EmailRecipients.  # noqa: E501
        :type: list[Recipient]
        """

        self._cc = cc

    @property
    def bcc(self):
        """Gets the bcc of this EmailRecipients.  # noqa: E501


        :return: The bcc of this EmailRecipients.  # noqa: E501
        :rtype: list[Recipient]
        """
        return self._bcc

    @bcc.setter
    def bcc(self, bcc):
        """Sets the bcc of this EmailRecipients.


        :param bcc: The bcc of this EmailRecipients.  # noqa: E501
        :type: list[Recipient]
        """

        self._bcc = bcc

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailRecipients):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailRecipients):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'attachments': 'list[str]',
        'inbox_id': 'str',
        'to': 'list[str]',
        'domain_id': 'str',
        'bcc': 'list[str]',
        'cc': 'list[str]',
        'read': 'bool',
        'body_excerpt': 'str',
        'team_access': 'bool',
        'body_md5_hash': 'str',
        'text_excerpt': 'str',
        'subject': 'str',
        'id': 'str',
        '_from': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'attachments': 'attachments',
        'inbox_id': 'inboxId',
        'to': 'to',
        'domain_id': 'domainId',
        'bcc': 'bcc',
        'cc': 'cc',
        'read': 'read',
        'body_excerpt': 'bodyExcerpt',
        'team_access': 'teamAccess',
        'body_md5_hash': 'bodyMD5Hash',
        'text_excerpt': 'textExcerpt',
        'subject': 'subject',
        'id': 'id',
        '_from': 'from'
    }

    def __init__(self, created_at=None, attachments=None, inbox_id=None, to=None, domain_id=None, bcc=None, cc=None, read=None, body_excerpt=None, team_access=None, body_md5_hash=None, text_excerpt=None, subject=None, id=None, _from=None, local_vars_configuration=None):  # noqa: E501
        """EmailProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._attachments = None
        self._inbox_id = None
        self._to = None
        self._domain_id = None
        self._bcc = None
        self._cc = None
        self._read = None
        self._body_excerpt = None
        self._team_access = None
        self._body_md5_hash = None
        self._text_excerpt = None
        self._subject = None
        self._id = None
        self.__from = None
        self.discriminator = None

        self.created_at = created_at
        self.attachments = attachments
        self.inbox_id = inbox_id
        self.to = to
        self.domain_id = domain_id
        self.bcc = bcc
        self.cc = cc
        self.read = read
        self.body_excerpt = body_excerpt
        self.team_access = team_access
        self.body_md5_hash = body_md5_hash
        self.text_excerpt = text_excerpt
        self.subject = subject
        self.id = id
        self._from = _from

    @property
    def created_at(self):
        """Gets the created_at of this EmailProjection.  # noqa: E501


        :return: The created_at of this EmailProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this EmailProjection.


        :param created_at: The created_at of this EmailProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def attachments(self):
        """Gets the attachments of this EmailProjection.  # noqa: E501


        :return: The attachments of this EmailProjection.  # noqa: E501
        :rtype: list[str]
        """
        return self._attachments

    @attachments.setter
    def attachments(self, attachments):
        """Sets the attachments of this EmailProjection.


        :param attachments: The attachments of this EmailProjection.  # noqa: E501
        :type: list[str]
        """

        self._attachments = attachments

    @property
    def inbox_id(self):
        """Gets the inbox_id of this EmailProjection.  # noqa: E501


        :return: The inbox_id of this EmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this EmailProjection.


        :param inbox_id: The inbox_id of this EmailProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def to(self):
        """Gets the to of this EmailProjection.  # noqa: E501


        :return: The to of this EmailProjection.  # noqa: E501
        :rtype: list[str]
        """
        return self._to

    @to.setter
    def to(self, to):
        """Sets the to of this EmailProjection.


        :param to: The to of this EmailProjection.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and to is None:  # noqa: E501
            raise ValueError("Invalid value for `to`, must not be `None`")  # noqa: E501

        self._to = to

    @property
    def domain_id(self):
        """Gets the domain_id of this EmailProjection.  # noqa: E501


        :return: The domain_id of this EmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._domain_id

    @domain_id.setter
    def domain_id(self, domain_id):
        """Sets the domain_id of this EmailProjection.


        :param domain_id: The domain_id of this EmailProjection.  # noqa: E501
        :type: str
        """

        self._domain_id = domain_id

    @property
    def bcc(self):
        """Gets the bcc of this EmailProjection.  # noqa: E501


        :return: The bcc of this EmailProjection.  # noqa: E501
        :rtype: list[str]
        """
        return self._bcc

    @bcc.setter
    def bcc(self, bcc):
        """Sets the bcc of this EmailProjection.


        :param bcc: The bcc of this EmailProjection.  # noqa: E501
        :type: list[str]
        """

        self._bcc = bcc

    @property
    def cc(self):
        """Gets the cc of this EmailProjection.  # noqa: E501


        :return: The cc of this EmailProjection.  # noqa: E501
        :rtype: list[str]
        """
        return self._cc

    @cc.setter
    def cc(self, cc):
        """Sets the cc of this EmailProjection.


        :param cc: The cc of this EmailProjection.  # noqa: E501
        :type: list[str]
        """

        self._cc = cc

    @property
    def read(self):
        """Gets the read of this EmailProjection.  # noqa: E501


        :return: The read of this EmailProjection.  # noqa: E501
        :rtype: bool
        """
        return self._read

    @read.setter
    def read(self, read):
        """Sets the read of this EmailProjection.


        :param read: The read of this EmailProjection.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and read is None:  # noqa: E501
            raise ValueError("Invalid value for `read`, must not be `None`")  # noqa: E501

        self._read = read

    @property
    def body_excerpt(self):
        """Gets the body_excerpt of this EmailProjection.  # noqa: E501


        :return: The body_excerpt of this EmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._body_excerpt

    @body_excerpt.setter
    def body_excerpt(self, body_excerpt):
        """Sets the body_excerpt of this EmailProjection.


        :param body_excerpt: The body_excerpt of this EmailProjection.  # noqa: E501
        :type: str
        """

        self._body_excerpt = body_excerpt

    @property
    def team_access(self):
        """Gets the team_access of this EmailProjection.  # noqa: E501


        :return: The team_access of this EmailProjection.  # noqa: E501
        :rtype: bool
        """
        return self._team_access

    @team_access.setter
    def team_access(self, team_access):
        """Sets the team_access of this EmailProjection.


        :param team_access: The team_access of this EmailProjection.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and team_access is None:  # noqa: E501
            raise ValueError("Invalid value for `team_access`, must not be `None`")  # noqa: E501

        self._team_access = team_access

    @property
    def body_md5_hash(self):
        """Gets the body_md5_hash of this EmailProjection.  # noqa: E501


        :return: The body_md5_hash of this EmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._body_md5_hash

    @body_md5_hash.setter
    def body_md5_hash(self, body_md5_hash):
        """Sets the body_md5_hash of this EmailProjection.


        :param body_md5_hash: The body_md5_hash of this EmailProjection.  # noqa: E501
        :type: str
        """

        self._body_md5_hash = body_md5_hash

    @property
    def text_excerpt(self):
        """Gets the text_excerpt of this EmailProjection.  # noqa: E501


        :return: The text_excerpt of this EmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._text_excerpt

    @text_excerpt.setter
    def text_excerpt(self, text_excerpt):
        """Sets the text_excerpt of this EmailProjection.


        :param text_excerpt: The text_excerpt of this EmailProjection.  # noqa: E501
        :type: str
        """

        self._text_excerpt = text_excerpt

    @property
    def subject(self):
        """Gets the subject of this EmailProjection.  # noqa: E501


        :return: The subject of this EmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this EmailProjection.


        :param subject: The subject of this EmailProjection.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def id(self):
        """Gets the id of this EmailProjection.  # noqa: E501


        :return: The id of this EmailProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this EmailProjection.


        :param id: The id of this EmailProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def _from(self):
        """Gets the _from of this EmailProjection.  # noqa: E501


        :return: The _from of this EmailProjection.  # noqa: E501
        :rtype: str
        """
        return self.__from

    @_from.setter
    def _from(self, _from):
        """Sets the _from of this EmailProjection.


        :param _from: The _from of this EmailProjection.  # noqa: E501
        :type: str
        """

        self.__from = _from

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_preview_urls.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailPreviewUrls(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'raw_smtp_message_url': 'str',
        'plain_html_body_url': 'str',
        'origin': 'str'
    }

    attribute_map = {
        'raw_smtp_message_url': 'rawSmtpMessageUrl',
        'plain_html_body_url': 'plainHtmlBodyUrl',
        'origin': 'origin'
    }

    def __init__(self, raw_smtp_message_url=None, plain_html_body_url=None, origin=None, local_vars_configuration=None):  # noqa: E501
        """EmailPreviewUrls - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._raw_smtp_message_url = None
        self._plain_html_body_url = None
        self._origin = None
        self.discriminator = None

        self.raw_smtp_message_url = raw_smtp_message_url
        self.plain_html_body_url = plain_html_body_url
        self.origin = origin

    @property
    def raw_smtp_message_url(self):
        """Gets the raw_smtp_message_url of this EmailPreviewUrls.  # noqa: E501


        :return: The raw_smtp_message_url of this EmailPreviewUrls.  # noqa: E501
        :rtype: str
        """
        return self._raw_smtp_message_url

    @raw_smtp_message_url.setter
    def raw_smtp_message_url(self, raw_smtp_message_url):
        """Sets the raw_smtp_message_url of this EmailPreviewUrls.


        :param raw_smtp_message_url: The raw_smtp_message_url of this EmailPreviewUrls.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and raw_smtp_message_url is None:  # noqa: E501
            raise ValueError("Invalid value for `raw_smtp_message_url`, must not be `None`")  # noqa: E501

        self._raw_smtp_message_url = raw_smtp_message_url

    @property
    def plain_html_body_url(self):
        """Gets the plain_html_body_url of this EmailPreviewUrls.  # noqa: E501


        :return: The plain_html_body_url of this EmailPreviewUrls.  # noqa: E501
        :rtype: str
        """
        return self._plain_html_body_url

    @plain_html_body_url.setter
    def plain_html_body_url(self, plain_html_body_url):
        """Sets the plain_html_body_url of this EmailPreviewUrls.


        :param plain_html_body_url: The plain_html_body_url of this EmailPreviewUrls.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and plain_html_body_url is None:  # noqa: E501
            raise ValueError("Invalid value for `plain_html_body_url`, must not be `None`")  # noqa: E501

        self._plain_html_body_url = plain_html_body_url

    @property
    def origin(self):
        """Gets the origin of this EmailPreviewUrls.  # noqa: E501


        :return: The origin of this EmailPreviewUrls.  # noqa: E501
        :rtype: str
        """
        return self._origin

    @origin.setter
    def origin(self, origin):
        """Sets the origin of this EmailPreviewUrls.


        :param origin: The origin of this EmailPreviewUrls.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and origin is None:  # noqa: E501
            raise ValueError("Invalid value for `origin`, must not be `None`")  # noqa: E501

        self._origin = origin

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailPreviewUrls):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailPreviewUrls):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_preview.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailPreview(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'domain_id': 'str',
        'subject': 'str',
        'to': 'list[str]',
        '_from': 'str',
        'bcc': 'list[str]',
        'cc': 'list[str]',
        'created_at': 'datetime',
        'read': 'bool',
        'attachments': 'list[str]'
    }

    attribute_map = {
        'id': 'id',
        'domain_id': 'domainId',
        'subject': 'subject',
        'to': 'to',
        '_from': 'from',
        'bcc': 'bcc',
        'cc': 'cc',
        'created_at': 'createdAt',
        'read': 'read',
        'attachments': 'attachments'
    }

    def __init__(self, id=None, domain_id=None, subject=None, to=None, _from=None, bcc=None, cc=None, created_at=None, read=None, attachments=None, local_vars_configuration=None):  # noqa: E501
        """EmailPreview - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._domain_id = None
        self._subject = None
        self._to = None
        self.__from = None
        self._bcc = None
        self._cc = None
        self._created_at = None
        self._read = None
        self._attachments = None
        self.discriminator = None

        self.id = id
        self.domain_id = domain_id
        self.subject = subject
        self.to = to
        self._from = _from
        self.bcc = bcc
        self.cc = cc
        self.created_at = created_at
        self.read = read
        self.attachments = attachments

    @property
    def id(self):
        """Gets the id of this EmailPreview.  # noqa: E501

        ID of the email entity  # noqa: E501

        :return: The id of this EmailPreview.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this EmailPreview.

        ID of the email entity  # noqa: E501

        :param id: The id of this EmailPreview.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def domain_id(self):
        """Gets the domain_id of this EmailPreview.  # noqa: E501

        ID of the domain that received the email  # noqa: E501

        :return: The domain_id of this EmailPreview.  # noqa: E501
        :rtype: str
        """
        return self._domain_id

    @domain_id.setter
    def domain_id(self, domain_id):
        """Sets the domain_id of this EmailPreview.

        ID of the domain that received the email  # noqa: E501

        :param domain_id: The domain_id of this EmailPreview.  # noqa: E501
        :type: str
        """

        self._domain_id = domain_id

    @property
    def subject(self):
        """Gets the subject of this EmailPreview.  # noqa: E501

        The subject line of the email message as specified by SMTP subject header  # noqa: E501

        :return: The subject of this EmailPreview.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this EmailPreview.

        The subject line of the email message as specified by SMTP subject header  # noqa: E501

        :param subject: The subject of this EmailPreview.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def to(self):
        """Gets the to of this EmailPreview.  # noqa: E501

        List of `To` recipient email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :return: The to of this EmailPreview.  # noqa: E501
        :rtype: list[str]
        """
        return self._to

    @to.setter
    def to(self, to):
        """Sets the to of this EmailPreview.

        List of `To` recipient email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :param to: The to of this EmailPreview.  # noqa: E501
        :type: list[str]
        """

        self._to = to

    @property
    def _from(self):
        """Gets the _from of this EmailPreview.  # noqa: E501

        Who the email was sent from. An email address - see fromName for the sender name.  # noqa: E501

        :return: The _from of this EmailPreview.  # noqa: E501
        :rtype: str
        """
        return self.__from

    @_from.setter
    def _from(self, _from):
        """Sets the _from of this EmailPreview.

        Who the email was sent from. An email address - see fromName for the sender name.  # noqa: E501

        :param _from: The _from of this EmailPreview.  # noqa: E501
        :type: str
        """

        self.__from = _from

    @property
    def bcc(self):
        """Gets the bcc of this EmailPreview.  # noqa: E501

        List of `BCC` recipients email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :return: The bcc of this EmailPreview.  # noqa: E501
        :rtype: list[str]
        """
        return self._bcc

    @bcc.setter
    def bcc(self, bcc):
        """Sets the bcc of this EmailPreview.

        List of `BCC` recipients email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :param bcc: The bcc of this EmailPreview.  # noqa: E501
        :type: list[str]
        """

        self._bcc = bcc

    @property
    def cc(self):
        """Gets the cc of this EmailPreview.  # noqa: E501

        List of `CC` recipients email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :return: The cc of this EmailPreview.  # noqa: E501
        :rtype: list[str]
        """
        return self._cc

    @cc.setter
    def cc(self, cc):
        """Sets the cc of this EmailPreview.

        List of `CC` recipients email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :param cc: The cc of this EmailPreview.  # noqa: E501
        :type: list[str]
        """

        self._cc = cc

    @property
    def created_at(self):
        """Gets the created_at of this EmailPreview.  # noqa: E501

        When was the email received by MailSlurp  # noqa: E501

        :return: The created_at of this EmailPreview.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this EmailPreview.

        When was the email received by MailSlurp  # noqa: E501

        :param created_at: The created_at of this EmailPreview.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def read(self):
        """Gets the read of this EmailPreview.  # noqa: E501

        Read flag. Has the email ever been viewed in the dashboard or fetched via the API with a hydrated body? If so the email is marked as read. Paginated results do not affect read status. Read status is different to email opened event as it depends on your own account accessing the email. Email opened is determined by tracking pixels sent to other uses if enable during sending. You can listened for both email read and email opened events using webhooks.  # noqa: E501

        :return: The read of this EmailPreview.  # noqa: E501
        :rtype: bool
        """
        return self._read

    @read.setter
    def read(self, read):
        """Sets the read of this EmailPreview.

        Read flag. Has the email ever been viewed in the dashboard or fetched via the API with a hydrated body? If so the email is marked as read. Paginated results do not affect read status. Read status is different to email opened event as it depends on your own account accessing the email. Email opened is determined by tracking pixels sent to other uses if enable during sending. You can listened for both email read and email opened events using webhooks.  # noqa: E501

        :param read: The read of this EmailPreview.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and read is None:  # noqa: E501
            raise ValueError("Invalid value for `read`, must not be `None`")  # noqa: E501

        self._read = read

    @property
    def attachments(self):
        """Gets the attachments of this EmailPreview.  # noqa: E501

        List of IDs of attachments found in the email. Use these IDs with the Inbox and Email Controllers to download attachments and attachment meta data such as filesize, name, extension.  # noqa: E501

        :return: The attachments of this EmailPreview.  # noqa: E501
        :rtype: list[str]
        """
        return self._attachments

    @attachments.setter
    def attachments(self, attachments):
        """Sets the attachments of this EmailPreview.

        List of IDs of attachments found in the email. Use these IDs with the Inbox and Email Controllers to download attachments and attachment meta data such as filesize, name, extension.  # noqa: E501

        :param attachments: The attachments of this EmailPreview.  # noqa: E501
        :type: list[str]
        """

        self._attachments = attachments

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailPreview):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailPreview):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_links_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailLinksResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'links': 'list[str]',
        'body': 'str'
    }

    attribute_map = {
        'links': 'links',
        'body': 'body'
    }

    def __init__(self, links=None, body=None, local_vars_configuration=None):  # noqa: E501
        """EmailLinksResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._links = None
        self._body = None
        self.discriminator = None

        self.links = links
        self.body = body

    @property
    def links(self):
        """Gets the links of this EmailLinksResult.  # noqa: E501


        :return: The links of this EmailLinksResult.  # noqa: E501
        :rtype: list[str]
        """
        return self._links

    @links.setter
    def links(self, links):
        """Sets the links of this EmailLinksResult.


        :param links: The links of this EmailLinksResult.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and links is None:  # noqa: E501
            raise ValueError("Invalid value for `links`, must not be `None`")  # noqa: E501

        self._links = links

    @property
    def body(self):
        """Gets the body of this EmailLinksResult.  # noqa: E501


        :return: The body of this EmailLinksResult.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this EmailLinksResult.


        :param body: The body of this EmailLinksResult.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and body is None:  # noqa: E501
            raise ValueError("Invalid value for `body`, must not be `None`")  # noqa: E501

        self._body = body

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailLinksResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailLinksResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_html_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailHtmlDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'subject': 'str',
        'body': 'str'
    }

    attribute_map = {
        'subject': 'subject',
        'body': 'body'
    }

    def __init__(self, subject=None, body=None, local_vars_configuration=None):  # noqa: E501
        """EmailHtmlDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._subject = None
        self._body = None
        self.discriminator = None

        if subject is not None:
            self.subject = subject
        if body is not None:
            self.body = body

    @property
    def subject(self):
        """Gets the subject of this EmailHtmlDto.  # noqa: E501


        :return: The subject of this EmailHtmlDto.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this EmailHtmlDto.


        :param subject: The subject of this EmailHtmlDto.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def body(self):
        """Gets the body of this EmailHtmlDto.  # noqa: E501


        :return: The body of this EmailHtmlDto.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this EmailHtmlDto.


        :param body: The body of this EmailHtmlDto.  # noqa: E501
        :type: str
        """

        self._body = body

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailHtmlDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailHtmlDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_feature_version_statistics.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailFeatureVersionStatistics(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'version': 'str',
        'support_flags': 'EmailFeatureSupportFlags'
    }

    attribute_map = {
        'version': 'version',
        'support_flags': 'supportFlags'
    }

    def __init__(self, version=None, support_flags=None, local_vars_configuration=None):  # noqa: E501
        """EmailFeatureVersionStatistics - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._version = None
        self._support_flags = None
        self.discriminator = None

        self.version = version
        self.support_flags = support_flags

    @property
    def version(self):
        """Gets the version of this EmailFeatureVersionStatistics.  # noqa: E501


        :return: The version of this EmailFeatureVersionStatistics.  # noqa: E501
        :rtype: str
        """
        return self._version

    @version.setter
    def version(self, version):
        """Sets the version of this EmailFeatureVersionStatistics.


        :param version: The version of this EmailFeatureVersionStatistics.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and version is None:  # noqa: E501
            raise ValueError("Invalid value for `version`, must not be `None`")  # noqa: E501

        self._version = version

    @property
    def support_flags(self):
        """Gets the support_flags of this EmailFeatureVersionStatistics.  # noqa: E501


        :return: The support_flags of this EmailFeatureVersionStatistics.  # noqa: E501
        :rtype: EmailFeatureSupportFlags
        """
        return self._support_flags

    @support_flags.setter
    def support_flags(self, support_flags):
        """Sets the support_flags of this EmailFeatureVersionStatistics.


        :param support_flags: The support_flags of this EmailFeatureVersionStatistics.  # noqa: E501
        :type: EmailFeatureSupportFlags
        """
        if self.local_vars_configuration.client_side_validation and support_flags is None:  # noqa: E501
            raise ValueError("Invalid value for `support_flags`, must not be `None`")  # noqa: E501

        self._support_flags = support_flags

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailFeatureVersionStatistics):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailFeatureVersionStatistics):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_feature_support_status_percentage.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailFeatureSupportStatusPercentage(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'status': 'str',
        'percentage': 'float'
    }

    attribute_map = {
        'status': 'status',
        'percentage': 'percentage'
    }

    def __init__(self, status=None, percentage=None, local_vars_configuration=None):  # noqa: E501
        """EmailFeatureSupportStatusPercentage - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._status = None
        self._percentage = None
        self.discriminator = None

        self.status = status
        self.percentage = percentage

    @property
    def status(self):
        """Gets the status of this EmailFeatureSupportStatusPercentage.  # noqa: E501


        :return: The status of this EmailFeatureSupportStatusPercentage.  # noqa: E501
        :rtype: str
        """
        return self._status

    @status.setter
    def status(self, status):
        """Sets the status of this EmailFeatureSupportStatusPercentage.


        :param status: The status of this EmailFeatureSupportStatusPercentage.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and status is None:  # noqa: E501
            raise ValueError("Invalid value for `status`, must not be `None`")  # noqa: E501
        allowed_values = ["SUPPORTED", "PARTIAL", "NOT_SUPPORTED", "UNKNOWN"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and status not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `status` ({0}), must be one of {1}"  # noqa: E501
                .format(status, allowed_values)
            )

        self._status = status

    @property
    def percentage(self):
        """Gets the percentage of this EmailFeatureSupportStatusPercentage.  # noqa: E501


        :return: The percentage of this EmailFeatureSupportStatusPercentage.  # noqa: E501
        :rtype: float
        """
        return self._percentage

    @percentage.setter
    def percentage(self, percentage):
        """Sets the percentage of this EmailFeatureSupportStatusPercentage.


        :param percentage: The percentage of this EmailFeatureSupportStatusPercentage.  # noqa: E501
        :type: float
        """
        if self.local_vars_configuration.client_side_validation and percentage is None:  # noqa: E501
            raise ValueError("Invalid value for `percentage`, must not be `None`")  # noqa: E501

        self._percentage = percentage

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailFeatureSupportStatusPercentage):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailFeatureSupportStatusPercentage):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_feature_support_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailFeatureSupportResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'names': 'EmailFeatureNames',
        'detected_features': 'list[str]',
        'feature_overviews': 'list[EmailFeatureOverview]',
        'feature_percentages': 'list[EmailFeatureSupportStatusPercentage]'
    }

    attribute_map = {
        'names': 'names',
        'detected_features': 'detectedFeatures',
        'feature_overviews': 'featureOverviews',
        'feature_percentages': 'featurePercentages'
    }

    def __init__(self, names=None, detected_features=None, feature_overviews=None, feature_percentages=None, local_vars_configuration=None):  # noqa: E501
        """EmailFeatureSupportResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._names = None
        self._detected_features = None
        self._feature_overviews = None
        self._feature_percentages = None
        self.discriminator = None

        self.names = names
        self.detected_features = detected_features
        self.feature_overviews = feature_overviews
        self.feature_percentages = feature_percentages

    @property
    def names(self):
        """Gets the names of this EmailFeatureSupportResult.  # noqa: E501


        :return: The names of this EmailFeatureSupportResult.  # noqa: E501
        :rtype: EmailFeatureNames
        """
        return self._names

    @names.setter
    def names(self, names):
        """Sets the names of this EmailFeatureSupportResult.


        :param names: The names of this EmailFeatureSupportResult.  # noqa: E501
        :type: EmailFeatureNames
        """
        if self.local_vars_configuration.client_side_validation and names is None:  # noqa: E501
            raise ValueError("Invalid value for `names`, must not be `None`")  # noqa: E501

        self._names = names

    @property
    def detected_features(self):
        """Gets the detected_features of this EmailFeatureSupportResult.  # noqa: E501


        :return: The detected_features of this EmailFeatureSupportResult.  # noqa: E501
        :rtype: list[str]
        """
        return self._detected_features

    @detected_features.setter
    def detected_features(self, detected_features):
        """Sets the detected_features of this EmailFeatureSupportResult.


        :param detected_features: The detected_features of this EmailFeatureSupportResult.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and detected_features is None:  # noqa: E501
            raise ValueError("Invalid value for `detected_features`, must not be `None`")  # noqa: E501
        allowed_values = ["amp", "css-accent-color", "css-align-items", "css-animation", "css-aspect-ratio", "css-at-font-face", "css-at-import", "css-at-keyframes", "css-at-media", "css-at-supports", "css-background-blend-mode", "css-background-clip", "css-background-color", "css-background-image", "css-background-origin", "css-background-position", "css-background-repeat", "css-background-size", "css-background", "css-block-inline-size", "css-border-image", "css-border-inline-block-individual", "css-border-inline-block-longhand", "css-border-inline-block", "css-border-radius-logical", "css-border-radius", "css-border", "css-box-shadow", "css-box-sizing", "css-caption-side", "css-clip-path", "css-column-count", "css-column-layout-properties", "css-direction", "css-display-flex", "css-display-grid", "css-display-none", "css-display", "css-filter", "css-flex-direction", "css-flex-wrap", "css-float", "css-font-kerning", "css-font-weight", "css-font", "css-gap", "css-grid-template", "css-height", "css-hyphens", "css-inline-size", "css-justify-content", "css-left-right-top-bottom", "css-letter-spacing", "css-line-height", "css-list-style-image", "css-list-style-position", "css-list-style-type", "css-list-style", "css-margin-block-start-end", "css-margin-inline-block", "css-margin-inline-start-end", "css-margin-inline", "css-margin", "css-max-block-size", "css-max-height", "css-max-width", "css-min-height", "css-min-inline-size", "css-min-width", "css-mix-blend-mode", "css-object-fit", "css-object-position", "css-opacity", "css-outline-offset", "css-outline", "css-overflow-wrap", "css-overflow", "css-padding-block-start-end", "css-padding-inline-block", "css-padding-inline-start-end", "css-padding", "css-position", "css-tab-size", "css-table-layout", "css-text-align-last", "css-text-align", "css-text-decoration-color", "css-text-decoration-thickness", "css-text-decoration", "css-text-emphasis-position", "css-text-emphasis", "css-text-indent", "css-text-overflow", "css-text-shadow", "css-text-transform", "css-text-underline-offset", "css-transform", "css-vertical-align", "css-visibility", "css-white-space", "css-width", "css-word-break", "css-writing-mode", "css-z-index", "html-abbr", "html-address", "html-align", "html-anchor-links", "html-aria-describedby", "html-aria-hidden", "html-aria-label", "html-aria-labelledby", "html-aria-live", "html-audio", "html-background", "html-base", "html-blockquote", "html-body", "html-button-reset", "html-button-submit", "html-code", "html-del", "html-dfn", "html-dialog", "html-dir", "html-div", "html-doctype", "html-form", "html-h1-h6", "html-height", "html-image-maps", "html-input-checkbox", "html-input-hidden", "html-input-radio", "html-input-reset", "html-input-submit", "html-input-text", "html-lang", "html-link", "html-lists", "html-loading-attribute", "html-mailto-links", "html-marquee", "html-meter", "html-object", "html-p", "html-picture", "html-pre", "html-progress", "html-required", "html-role", "html-rp", "html-rt", "html-ruby", "html-select", "html-semantics", "html-small", "html-span", "html-srcset", "html-strike", "html-strong", "html-style", "html-svg", "html-table", "html-target", "html-textarea", "html-valign", "html-video", "html-wbr", "html-width", "image-avif", "image-base64", "image-bmp", "image-gif", "image-ico", "image-jpg", "image-png", "image-svg", "image-webp", "unsupported"]  # noqa: E501
        if (self.local_vars_configuration.client_side_validation and
                not set(detected_features).issubset(set(allowed_values))):  # noqa: E501
            raise ValueError(
                "Invalid values for `detected_features` [{0}], must be a subset of [{1}]"  # noqa: E501
                .format(", ".join(map(str, set(detected_features) - set(allowed_values))),  # noqa: E501
                        ", ".join(map(str, allowed_values)))
            )

        self._detected_features = detected_features

    @property
    def feature_overviews(self):
        """Gets the feature_overviews of this EmailFeatureSupportResult.  # noqa: E501


        :return: The feature_overviews of this EmailFeatureSupportResult.  # noqa: E501
        :rtype: list[EmailFeatureOverview]
        """
        return self._feature_overviews

    @feature_overviews.setter
    def feature_overviews(self, feature_overviews):
        """Sets the feature_overviews of this EmailFeatureSupportResult.


        :param feature_overviews: The feature_overviews of this EmailFeatureSupportResult.  # noqa: E501
        :type: list[EmailFeatureOverview]
        """
        if self.local_vars_configuration.client_side_validation and feature_overviews is None:  # noqa: E501
            raise ValueError("Invalid value for `feature_overviews`, must not be `None`")  # noqa: E501

        self._feature_overviews = feature_overviews

    @property
    def feature_percentages(self):
        """Gets the feature_percentages of this EmailFeatureSupportResult.  # noqa: E501


        :return: The feature_percentages of this EmailFeatureSupportResult.  # noqa: E501
        :rtype: list[EmailFeatureSupportStatusPercentage]
        """
        return self._feature_percentages

    @feature_percentages.setter
    def feature_percentages(self, feature_percentages):
        """Sets the feature_percentages of this EmailFeatureSupportResult.


        :param feature_percentages: The feature_percentages of this EmailFeatureSupportResult.  # noqa: E501
        :type: list[EmailFeatureSupportStatusPercentage]
        """
        if self.local_vars_configuration.client_side_validation and feature_percentages is None:  # noqa: E501
            raise ValueError("Invalid value for `feature_percentages`, must not be `None`")  # noqa: E501

        self._feature_percentages = feature_percentages

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailFeatureSupportResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailFeatureSupportResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_feature_support_flags.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailFeatureSupportFlags(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'status': 'str',
        'notes': 'list[str]'
    }

    attribute_map = {
        'status': 'status',
        'notes': 'notes'
    }

    def __init__(self, status=None, notes=None, local_vars_configuration=None):  # noqa: E501
        """EmailFeatureSupportFlags - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._status = None
        self._notes = None
        self.discriminator = None

        self.status = status
        if notes is not None:
            self.notes = notes

    @property
    def status(self):
        """Gets the status of this EmailFeatureSupportFlags.  # noqa: E501


        :return: The status of this EmailFeatureSupportFlags.  # noqa: E501
        :rtype: str
        """
        return self._status

    @status.setter
    def status(self, status):
        """Sets the status of this EmailFeatureSupportFlags.


        :param status: The status of this EmailFeatureSupportFlags.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and status is None:  # noqa: E501
            raise ValueError("Invalid value for `status`, must not be `None`")  # noqa: E501
        allowed_values = ["SUPPORTED", "PARTIAL", "NOT_SUPPORTED", "UNKNOWN"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and status not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `status` ({0}), must be one of {1}"  # noqa: E501
                .format(status, allowed_values)
            )

        self._status = status

    @property
    def notes(self):
        """Gets the notes of this EmailFeatureSupportFlags.  # noqa: E501


        :return: The notes of this EmailFeatureSupportFlags.  # noqa: E501
        :rtype: list[str]
        """
        return self._notes

    @notes.setter
    def notes(self, notes):
        """Sets the notes of this EmailFeatureSupportFlags.


        :param notes: The notes of this EmailFeatureSupportFlags.  # noqa: E501
        :type: list[str]
        """

        self._notes = notes

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailFeatureSupportFlags):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailFeatureSupportFlags):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_feature_platform_statistics.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailFeaturePlatformStatistics(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'platform': 'str',
        'versions': 'list[EmailFeatureVersionStatistics]'
    }

    attribute_map = {
        'platform': 'platform',
        'versions': 'versions'
    }

    def __init__(self, platform=None, versions=None, local_vars_configuration=None):  # noqa: E501
        """EmailFeaturePlatformStatistics - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._platform = None
        self._versions = None
        self.discriminator = None

        self.platform = platform
        self.versions = versions

    @property
    def platform(self):
        """Gets the platform of this EmailFeaturePlatformStatistics.  # noqa: E501


        :return: The platform of this EmailFeaturePlatformStatistics.  # noqa: E501
        :rtype: str
        """
        return self._platform

    @platform.setter
    def platform(self, platform):
        """Sets the platform of this EmailFeaturePlatformStatistics.


        :param platform: The platform of this EmailFeaturePlatformStatistics.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and platform is None:  # noqa: E501
            raise ValueError("Invalid value for `platform`, must not be `None`")  # noqa: E501
        allowed_values = ["android", "desktop-app", "desktop-webmail", "ios", "macos", "mobile-webmail", "outlook-com", "webmail", "windows", "windows-mail"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and platform not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `platform` ({0}), must be one of {1}"  # noqa: E501
                .format(platform, allowed_values)
            )

        self._platform = platform

    @property
    def versions(self):
        """Gets the versions of this EmailFeaturePlatformStatistics.  # noqa: E501


        :return: The versions of this EmailFeaturePlatformStatistics.  # noqa: E501
        :rtype: list[EmailFeatureVersionStatistics]
        """
        return self._versions

    @versions.setter
    def versions(self, versions):
        """Sets the versions of this EmailFeaturePlatformStatistics.


        :param versions: The versions of this EmailFeaturePlatformStatistics.  # noqa: E501
        :type: list[EmailFeatureVersionStatistics]
        """
        if self.local_vars_configuration.client_side_validation and versions is None:  # noqa: E501
            raise ValueError("Invalid value for `versions`, must not be `None`")  # noqa: E501

        self._versions = versions

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailFeaturePlatformStatistics):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailFeaturePlatformStatistics):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_feature_platform_name.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailFeaturePlatformName(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'slug': 'str',
        'name': 'str'
    }

    attribute_map = {
        'slug': 'slug',
        'name': 'name'
    }

    def __init__(self, slug=None, name=None, local_vars_configuration=None):  # noqa: E501
        """EmailFeaturePlatformName - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._slug = None
        self._name = None
        self.discriminator = None

        self.slug = slug
        self.name = name

    @property
    def slug(self):
        """Gets the slug of this EmailFeaturePlatformName.  # noqa: E501


        :return: The slug of this EmailFeaturePlatformName.  # noqa: E501
        :rtype: str
        """
        return self._slug

    @slug.setter
    def slug(self, slug):
        """Sets the slug of this EmailFeaturePlatformName.


        :param slug: The slug of this EmailFeaturePlatformName.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and slug is None:  # noqa: E501
            raise ValueError("Invalid value for `slug`, must not be `None`")  # noqa: E501
        allowed_values = ["android", "desktop-app", "desktop-webmail", "ios", "macos", "mobile-webmail", "outlook-com", "webmail", "windows", "windows-mail"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and slug not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `slug` ({0}), must be one of {1}"  # noqa: E501
                .format(slug, allowed_values)
            )

        self._slug = slug

    @property
    def name(self):
        """Gets the name of this EmailFeaturePlatformName.  # noqa: E501


        :return: The name of this EmailFeaturePlatformName.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this EmailFeaturePlatformName.


        :param name: The name of this EmailFeaturePlatformName.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailFeaturePlatformName):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailFeaturePlatformName):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_feature_overview.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailFeatureOverview(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'feature': 'str',
        'title': 'str',
        'description': 'str',
        'category': 'str',
        'notes': 'str',
        'notes_numbers': 'dict(str, str)',
        'feature_statistics': 'list[EmailFeatureFamilyStatistics]',
        'statuses': 'list[str]'
    }

    attribute_map = {
        'feature': 'feature',
        'title': 'title',
        'description': 'description',
        'category': 'category',
        'notes': 'notes',
        'notes_numbers': 'notesNumbers',
        'feature_statistics': 'featureStatistics',
        'statuses': 'statuses'
    }

    def __init__(self, feature=None, title=None, description=None, category=None, notes=None, notes_numbers=None, feature_statistics=None, statuses=None, local_vars_configuration=None):  # noqa: E501
        """EmailFeatureOverview - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._feature = None
        self._title = None
        self._description = None
        self._category = None
        self._notes = None
        self._notes_numbers = None
        self._feature_statistics = None
        self._statuses = None
        self.discriminator = None

        self.feature = feature
        if title is not None:
            self.title = title
        if description is not None:
            self.description = description
        if category is not None:
            self.category = category
        if notes is not None:
            self.notes = notes
        if notes_numbers is not None:
            self.notes_numbers = notes_numbers
        if feature_statistics is not None:
            self.feature_statistics = feature_statistics
        self.statuses = statuses

    @property
    def feature(self):
        """Gets the feature of this EmailFeatureOverview.  # noqa: E501


        :return: The feature of this EmailFeatureOverview.  # noqa: E501
        :rtype: str
        """
        return self._feature

    @feature.setter
    def feature(self, feature):
        """Sets the feature of this EmailFeatureOverview.


        :param feature: The feature of this EmailFeatureOverview.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and feature is None:  # noqa: E501
            raise ValueError("Invalid value for `feature`, must not be `None`")  # noqa: E501
        allowed_values = ["amp", "css-accent-color", "css-align-items", "css-animation", "css-aspect-ratio", "css-at-font-face", "css-at-import", "css-at-keyframes", "css-at-media", "css-at-supports", "css-background-blend-mode", "css-background-clip", "css-background-color", "css-background-image", "css-background-origin", "css-background-position", "css-background-repeat", "css-background-size", "css-background", "css-block-inline-size", "css-border-image", "css-border-inline-block-individual", "css-border-inline-block-longhand", "css-border-inline-block", "css-border-radius-logical", "css-border-radius", "css-border", "css-box-shadow", "css-box-sizing", "css-caption-side", "css-clip-path", "css-column-count", "css-column-layout-properties", "css-direction", "css-display-flex", "css-display-grid", "css-display-none", "css-display", "css-filter", "css-flex-direction", "css-flex-wrap", "css-float", "css-font-kerning", "css-font-weight", "css-font", "css-gap", "css-grid-template", "css-height", "css-hyphens", "css-inline-size", "css-justify-content", "css-left-right-top-bottom", "css-letter-spacing", "css-line-height", "css-list-style-image", "css-list-style-position", "css-list-style-type", "css-list-style", "css-margin-block-start-end", "css-margin-inline-block", "css-margin-inline-start-end", "css-margin-inline", "css-margin", "css-max-block-size", "css-max-height", "css-max-width", "css-min-height", "css-min-inline-size", "css-min-width", "css-mix-blend-mode", "css-object-fit", "css-object-position", "css-opacity", "css-outline-offset", "css-outline", "css-overflow-wrap", "css-overflow", "css-padding-block-start-end", "css-padding-inline-block", "css-padding-inline-start-end", "css-padding", "css-position", "css-tab-size", "css-table-layout", "css-text-align-last", "css-text-align", "css-text-decoration-color", "css-text-decoration-thickness", "css-text-decoration", "css-text-emphasis-position", "css-text-emphasis", "css-text-indent", "css-text-overflow", "css-text-shadow", "css-text-transform", "css-text-underline-offset", "css-transform", "css-vertical-align", "css-visibility", "css-white-space", "css-width", "css-word-break", "css-writing-mode", "css-z-index", "html-abbr", "html-address", "html-align", "html-anchor-links", "html-aria-describedby", "html-aria-hidden", "html-aria-label", "html-aria-labelledby", "html-aria-live", "html-audio", "html-background", "html-base", "html-blockquote", "html-body", "html-button-reset", "html-button-submit", "html-code", "html-del", "html-dfn", "html-dialog", "html-dir", "html-div", "html-doctype", "html-form", "html-h1-h6", "html-height", "html-image-maps", "html-input-checkbox", "html-input-hidden", "html-input-radio", "html-input-reset", "html-input-submit", "html-input-text", "html-lang", "html-link", "html-lists", "html-loading-attribute", "html-mailto-links", "html-marquee", "html-meter", "html-object", "html-p", "html-picture", "html-pre", "html-progress", "html-required", "html-role", "html-rp", "html-rt", "html-ruby", "html-select", "html-semantics", "html-small", "html-span", "html-srcset", "html-strike", "html-strong", "html-style", "html-svg", "html-table", "html-target", "html-textarea", "html-valign", "html-video", "html-wbr", "html-width", "image-avif", "image-base64", "image-bmp", "image-gif", "image-ico", "image-jpg", "image-png", "image-svg", "image-webp", "unsupported"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and feature not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `feature` ({0}), must be one of {1}"  # noqa: E501
                .format(feature, allowed_values)
            )

        self._feature = feature

    @property
    def title(self):
        """Gets the title of this EmailFeatureOverview.  # noqa: E501


        :return: The title of this EmailFeatureOverview.  # noqa: E501
        :rtype: str
        """
        return self._title

    @title.setter
    def title(self, title):
        """Sets the title of this EmailFeatureOverview.


        :param title: The title of this EmailFeatureOverview.  # noqa: E501
        :type: str
        """

        self._title = title

    @property
    def description(self):
        """Gets the description of this EmailFeatureOverview.  # noqa: E501


        :return: The description of this EmailFeatureOverview.  # noqa: E501
        :rtype: str
        """
        return self._description

    @description.setter
    def description(self, description):
        """Sets the description of this EmailFeatureOverview.


        :param description: The description of this EmailFeatureOverview.  # noqa: E501
        :type: str
        """

        self._description = description

    @property
    def category(self):
        """Gets the category of this EmailFeatureOverview.  # noqa: E501


        :return: The category of this EmailFeatureOverview.  # noqa: E501
        :rtype: str
        """
        return self._category

    @category.setter
    def category(self, category):
        """Sets the category of this EmailFeatureOverview.


        :param category: The category of this EmailFeatureOverview.  # noqa: E501
        :type: str
        """
        allowed_values = ["css", "html", "image", "others"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and category not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `category` ({0}), must be one of {1}"  # noqa: E501
                .format(category, allowed_values)
            )

        self._category = category

    @property
    def notes(self):
        """Gets the notes of this EmailFeatureOverview.  # noqa: E501


        :return: The notes of this EmailFeatureOverview.  # noqa: E501
        :rtype: str
        """
        return self._notes

    @notes.setter
    def notes(self, notes):
        """Sets the notes of this EmailFeatureOverview.


        :param notes: The notes of this EmailFeatureOverview.  # noqa: E501
        :type: str
        """

        self._notes = notes

    @property
    def notes_numbers(self):
        """Gets the notes_numbers of this EmailFeatureOverview.  # noqa: E501


        :return: The notes_numbers of this EmailFeatureOverview.  # noqa: E501
        :rtype: dict(str, str)
        """
        return self._notes_numbers

    @notes_numbers.setter
    def notes_numbers(self, notes_numbers):
        """Sets the notes_numbers of this EmailFeatureOverview.


        :param notes_numbers: The notes_numbers of this EmailFeatureOverview.  # noqa: E501
        :type: dict(str, str)
        """

        self._notes_numbers = notes_numbers

    @property
    def feature_statistics(self):
        """Gets the feature_statistics of this EmailFeatureOverview.  # noqa: E501


        :return: The feature_statistics of this EmailFeatureOverview.  # noqa: E501
        :rtype: list[EmailFeatureFamilyStatistics]
        """
        return self._feature_statistics

    @feature_statistics.setter
    def feature_statistics(self, feature_statistics):
        """Sets the feature_statistics of this EmailFeatureOverview.


        :param feature_statistics: The feature_statistics of this EmailFeatureOverview.  # noqa: E501
        :type: list[EmailFeatureFamilyStatistics]
        """

        self._feature_statistics = feature_statistics

    @property
    def statuses(self):
        """Gets the statuses of this EmailFeatureOverview.  # noqa: E501


        :return: The statuses of this EmailFeatureOverview.  # noqa: E501
        :rtype: list[str]
        """
        return self._statuses

    @statuses.setter
    def statuses(self, statuses):
        """Sets the statuses of this EmailFeatureOverview.


        :param statuses: The statuses of this EmailFeatureOverview.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and statuses is None:  # noqa: E501
            raise ValueError("Invalid value for `statuses`, must not be `None`")  # noqa: E501
        allowed_values = ["SUPPORTED", "PARTIAL", "NOT_SUPPORTED", "UNKNOWN"]  # noqa: E501
        if (self.local_vars_configuration.client_side_validation and
                not set(statuses).issubset(set(allowed_values))):  # noqa: E501
            raise ValueError(
                "Invalid values for `statuses` [{0}], must be a subset of [{1}]"  # noqa: E501
                .format(", ".join(map(str, set(statuses) - set(allowed_values))),  # noqa: E501
                        ", ".join(map(str, allowed_values)))
            )

        self._statuses = statuses

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailFeatureOverview):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailFeatureOverview):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_feature_names.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailFeatureNames(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'family': 'list[EmailFeatureFamilyName]',
        'platform': 'list[EmailFeaturePlatformName]',
        'category': 'list[EmailFeatureCategoryName]'
    }

    attribute_map = {
        'family': 'family',
        'platform': 'platform',
        'category': 'category'
    }

    def __init__(self, family=None, platform=None, category=None, local_vars_configuration=None):  # noqa: E501
        """EmailFeatureNames - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._family = None
        self._platform = None
        self._category = None
        self.discriminator = None

        self.family = family
        self.platform = platform
        self.category = category

    @property
    def family(self):
        """Gets the family of this EmailFeatureNames.  # noqa: E501


        :return: The family of this EmailFeatureNames.  # noqa: E501
        :rtype: list[EmailFeatureFamilyName]
        """
        return self._family

    @family.setter
    def family(self, family):
        """Sets the family of this EmailFeatureNames.


        :param family: The family of this EmailFeatureNames.  # noqa: E501
        :type: list[EmailFeatureFamilyName]
        """
        if self.local_vars_configuration.client_side_validation and family is None:  # noqa: E501
            raise ValueError("Invalid value for `family`, must not be `None`")  # noqa: E501

        self._family = family

    @property
    def platform(self):
        """Gets the platform of this EmailFeatureNames.  # noqa: E501


        :return: The platform of this EmailFeatureNames.  # noqa: E501
        :rtype: list[EmailFeaturePlatformName]
        """
        return self._platform

    @platform.setter
    def platform(self, platform):
        """Sets the platform of this EmailFeatureNames.


        :param platform: The platform of this EmailFeatureNames.  # noqa: E501
        :type: list[EmailFeaturePlatformName]
        """
        if self.local_vars_configuration.client_side_validation and platform is None:  # noqa: E501
            raise ValueError("Invalid value for `platform`, must not be `None`")  # noqa: E501

        self._platform = platform

    @property
    def category(self):
        """Gets the category of this EmailFeatureNames.  # noqa: E501


        :return: The category of this EmailFeatureNames.  # noqa: E501
        :rtype: list[EmailFeatureCategoryName]
        """
        return self._category

    @category.setter
    def category(self, category):
        """Sets the category of this EmailFeatureNames.


        :param category: The category of this EmailFeatureNames.  # noqa: E501
        :type: list[EmailFeatureCategoryName]
        """
        if self.local_vars_configuration.client_side_validation and category is None:  # noqa: E501
            raise ValueError("Invalid value for `category`, must not be `None`")  # noqa: E501

        self._category = category

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailFeatureNames):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailFeatureNames):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_feature_family_statistics.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailFeatureFamilyStatistics(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'feature': 'str',
        'family': 'str',
        'platforms': 'list[EmailFeaturePlatformStatistics]'
    }

    attribute_map = {
        'feature': 'feature',
        'family': 'family',
        'platforms': 'platforms'
    }

    def __init__(self, feature=None, family=None, platforms=None, local_vars_configuration=None):  # noqa: E501
        """EmailFeatureFamilyStatistics - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._feature = None
        self._family = None
        self._platforms = None
        self.discriminator = None

        self.feature = feature
        self.family = family
        self.platforms = platforms

    @property
    def feature(self):
        """Gets the feature of this EmailFeatureFamilyStatistics.  # noqa: E501


        :return: The feature of this EmailFeatureFamilyStatistics.  # noqa: E501
        :rtype: str
        """
        return self._feature

    @feature.setter
    def feature(self, feature):
        """Sets the feature of this EmailFeatureFamilyStatistics.


        :param feature: The feature of this EmailFeatureFamilyStatistics.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and feature is None:  # noqa: E501
            raise ValueError("Invalid value for `feature`, must not be `None`")  # noqa: E501
        allowed_values = ["amp", "css-accent-color", "css-align-items", "css-animation", "css-aspect-ratio", "css-at-font-face", "css-at-import", "css-at-keyframes", "css-at-media", "css-at-supports", "css-background-blend-mode", "css-background-clip", "css-background-color", "css-background-image", "css-background-origin", "css-background-position", "css-background-repeat", "css-background-size", "css-background", "css-block-inline-size", "css-border-image", "css-border-inline-block-individual", "css-border-inline-block-longhand", "css-border-inline-block", "css-border-radius-logical", "css-border-radius", "css-border", "css-box-shadow", "css-box-sizing", "css-caption-side", "css-clip-path", "css-column-count", "css-column-layout-properties", "css-direction", "css-display-flex", "css-display-grid", "css-display-none", "css-display", "css-filter", "css-flex-direction", "css-flex-wrap", "css-float", "css-font-kerning", "css-font-weight", "css-font", "css-gap", "css-grid-template", "css-height", "css-hyphens", "css-inline-size", "css-justify-content", "css-left-right-top-bottom", "css-letter-spacing", "css-line-height", "css-list-style-image", "css-list-style-position", "css-list-style-type", "css-list-style", "css-margin-block-start-end", "css-margin-inline-block", "css-margin-inline-start-end", "css-margin-inline", "css-margin", "css-max-block-size", "css-max-height", "css-max-width", "css-min-height", "css-min-inline-size", "css-min-width", "css-mix-blend-mode", "css-object-fit", "css-object-position", "css-opacity", "css-outline-offset", "css-outline", "css-overflow-wrap", "css-overflow", "css-padding-block-start-end", "css-padding-inline-block", "css-padding-inline-start-end", "css-padding", "css-position", "css-tab-size", "css-table-layout", "css-text-align-last", "css-text-align", "css-text-decoration-color", "css-text-decoration-thickness", "css-text-decoration", "css-text-emphasis-position", "css-text-emphasis", "css-text-indent", "css-text-overflow", "css-text-shadow", "css-text-transform", "css-text-underline-offset", "css-transform", "css-vertical-align", "css-visibility", "css-white-space", "css-width", "css-word-break", "css-writing-mode", "css-z-index", "html-abbr", "html-address", "html-align", "html-anchor-links", "html-aria-describedby", "html-aria-hidden", "html-aria-label", "html-aria-labelledby", "html-aria-live", "html-audio", "html-background", "html-base", "html-blockquote", "html-body", "html-button-reset", "html-button-submit", "html-code", "html-del", "html-dfn", "html-dialog", "html-dir", "html-div", "html-doctype", "html-form", "html-h1-h6", "html-height", "html-image-maps", "html-input-checkbox", "html-input-hidden", "html-input-radio", "html-input-reset", "html-input-submit", "html-input-text", "html-lang", "html-link", "html-lists", "html-loading-attribute", "html-mailto-links", "html-marquee", "html-meter", "html-object", "html-p", "html-picture", "html-pre", "html-progress", "html-required", "html-role", "html-rp", "html-rt", "html-ruby", "html-select", "html-semantics", "html-small", "html-span", "html-srcset", "html-strike", "html-strong", "html-style", "html-svg", "html-table", "html-target", "html-textarea", "html-valign", "html-video", "html-wbr", "html-width", "image-avif", "image-base64", "image-bmp", "image-gif", "image-ico", "image-jpg", "image-png", "image-svg", "image-webp", "unsupported"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and feature not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `feature` ({0}), must be one of {1}"  # noqa: E501
                .format(feature, allowed_values)
            )

        self._feature = feature

    @property
    def family(self):
        """Gets the family of this EmailFeatureFamilyStatistics.  # noqa: E501


        :return: The family of this EmailFeatureFamilyStatistics.  # noqa: E501
        :rtype: str
        """
        return self._family

    @family.setter
    def family(self, family):
        """Sets the family of this EmailFeatureFamilyStatistics.


        :param family: The family of this EmailFeatureFamilyStatistics.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and family is None:  # noqa: E501
            raise ValueError("Invalid value for `family`, must not be `None`")  # noqa: E501
        allowed_values = ["aol", "apple-mail", "fastmail", "free-fr", "gmail", "gmx", "hey", "ionos-1and1", "laposte", "mail-ru", "microsoft", "orange", "outlook", "protonmail", "rainloop", "samsung-email", "sfr", "t-online-de", "thunderbird", "web-de", "yahoo"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and family not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `family` ({0}), must be one of {1}"  # noqa: E501
                .format(family, allowed_values)
            )

        self._family = family

    @property
    def platforms(self):
        """Gets the platforms of this EmailFeatureFamilyStatistics.  # noqa: E501


        :return: The platforms of this EmailFeatureFamilyStatistics.  # noqa: E501
        :rtype: list[EmailFeaturePlatformStatistics]
        """
        return self._platforms

    @platforms.setter
    def platforms(self, platforms):
        """Sets the platforms of this EmailFeatureFamilyStatistics.


        :param platforms: The platforms of this EmailFeatureFamilyStatistics.  # noqa: E501
        :type: list[EmailFeaturePlatformStatistics]
        """
        if self.local_vars_configuration.client_side_validation and platforms is None:  # noqa: E501
            raise ValueError("Invalid value for `platforms`, must not be `None`")  # noqa: E501

        self._platforms = platforms

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailFeatureFamilyStatistics):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailFeatureFamilyStatistics):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_feature_family_name.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailFeatureFamilyName(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'slug': 'str',
        'name': 'str'
    }

    attribute_map = {
        'slug': 'slug',
        'name': 'name'
    }

    def __init__(self, slug=None, name=None, local_vars_configuration=None):  # noqa: E501
        """EmailFeatureFamilyName - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._slug = None
        self._name = None
        self.discriminator = None

        self.slug = slug
        self.name = name

    @property
    def slug(self):
        """Gets the slug of this EmailFeatureFamilyName.  # noqa: E501


        :return: The slug of this EmailFeatureFamilyName.  # noqa: E501
        :rtype: str
        """
        return self._slug

    @slug.setter
    def slug(self, slug):
        """Sets the slug of this EmailFeatureFamilyName.


        :param slug: The slug of this EmailFeatureFamilyName.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and slug is None:  # noqa: E501
            raise ValueError("Invalid value for `slug`, must not be `None`")  # noqa: E501
        allowed_values = ["aol", "apple-mail", "fastmail", "free-fr", "gmail", "gmx", "hey", "ionos-1and1", "laposte", "mail-ru", "microsoft", "orange", "outlook", "protonmail", "rainloop", "samsung-email", "sfr", "t-online-de", "thunderbird", "web-de", "yahoo"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and slug not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `slug` ({0}), must be one of {1}"  # noqa: E501
                .format(slug, allowed_values)
            )

        self._slug = slug

    @property
    def name(self):
        """Gets the name of this EmailFeatureFamilyName.  # noqa: E501


        :return: The name of this EmailFeatureFamilyName.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this EmailFeatureFamilyName.


        :param name: The name of this EmailFeatureFamilyName.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailFeatureFamilyName):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailFeatureFamilyName):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_feature_category_name.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailFeatureCategoryName(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'slug': 'str',
        'name': 'str'
    }

    attribute_map = {
        'slug': 'slug',
        'name': 'name'
    }

    def __init__(self, slug=None, name=None, local_vars_configuration=None):  # noqa: E501
        """EmailFeatureCategoryName - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._slug = None
        self._name = None
        self.discriminator = None

        self.slug = slug
        self.name = name

    @property
    def slug(self):
        """Gets the slug of this EmailFeatureCategoryName.  # noqa: E501


        :return: The slug of this EmailFeatureCategoryName.  # noqa: E501
        :rtype: str
        """
        return self._slug

    @slug.setter
    def slug(self, slug):
        """Sets the slug of this EmailFeatureCategoryName.


        :param slug: The slug of this EmailFeatureCategoryName.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and slug is None:  # noqa: E501
            raise ValueError("Invalid value for `slug`, must not be `None`")  # noqa: E501
        allowed_values = ["css", "html", "image", "others"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and slug not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `slug` ({0}), must be one of {1}"  # noqa: E501
                .format(slug, allowed_values)
            )

        self._slug = slug

    @property
    def name(self):
        """Gets the name of this EmailFeatureCategoryName.  # noqa: E501


        :return: The name of this EmailFeatureCategoryName.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this EmailFeatureCategoryName.


        :param name: The name of this EmailFeatureCategoryName.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailFeatureCategoryName):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailFeatureCategoryName):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_content_part_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailContentPartResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'content': 'str'
    }

    attribute_map = {
        'content': 'content'
    }

    def __init__(self, content=None, local_vars_configuration=None):  # noqa: E501
        """EmailContentPartResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._content = None
        self.discriminator = None

        self.content = content

    @property
    def content(self):
        """Gets the content of this EmailContentPartResult.  # noqa: E501


        :return: The content of this EmailContentPartResult.  # noqa: E501
        :rtype: str
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this EmailContentPartResult.


        :param content: The content of this EmailContentPartResult.  # noqa: E501
        :type: str
        """

        self._content = content

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailContentPartResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailContentPartResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_content_match_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailContentMatchResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'pattern': 'str',
        'matches': 'list[str]'
    }

    attribute_map = {
        'pattern': 'pattern',
        'matches': 'matches'
    }

    def __init__(self, pattern=None, matches=None, local_vars_configuration=None):  # noqa: E501
        """EmailContentMatchResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._pattern = None
        self._matches = None
        self.discriminator = None

        self.pattern = pattern
        self.matches = matches

    @property
    def pattern(self):
        """Gets the pattern of this EmailContentMatchResult.  # noqa: E501


        :return: The pattern of this EmailContentMatchResult.  # noqa: E501
        :rtype: str
        """
        return self._pattern

    @pattern.setter
    def pattern(self, pattern):
        """Sets the pattern of this EmailContentMatchResult.


        :param pattern: The pattern of this EmailContentMatchResult.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and pattern is None:  # noqa: E501
            raise ValueError("Invalid value for `pattern`, must not be `None`")  # noqa: E501

        self._pattern = pattern

    @property
    def matches(self):
        """Gets the matches of this EmailContentMatchResult.  # noqa: E501


        :return: The matches of this EmailContentMatchResult.  # noqa: E501
        :rtype: list[str]
        """
        return self._matches

    @matches.setter
    def matches(self, matches):
        """Sets the matches of this EmailContentMatchResult.


        :param matches: The matches of this EmailContentMatchResult.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and matches is None:  # noqa: E501
            raise ValueError("Invalid value for `matches`, must not be `None`")  # noqa: E501

        self._matches = matches

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailContentMatchResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailContentMatchResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_available_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailAvailableResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'available': 'bool'
    }

    attribute_map = {
        'available': 'available'
    }

    def __init__(self, available=None, local_vars_configuration=None):  # noqa: E501
        """EmailAvailableResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._available = None
        self.discriminator = None

        self.available = available

    @property
    def available(self):
        """Gets the available of this EmailAvailableResult.  # noqa: E501


        :return: The available of this EmailAvailableResult.  # noqa: E501
        :rtype: bool
        """
        return self._available

    @available.setter
    def available(self, available):
        """Sets the available of this EmailAvailableResult.


        :param available: The available of this EmailAvailableResult.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and available is None:  # noqa: E501
            raise ValueError("Invalid value for `available`, must not be `None`")  # noqa: E501

        self._available = available

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailAvailableResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailAvailableResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email_analysis.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class EmailAnalysis(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'spam_verdict': 'str',
        'virus_verdict': 'str',
        'spf_verdict': 'str',
        'dkim_verdict': 'str',
        'dmarc_verdict': 'str'
    }

    attribute_map = {
        'spam_verdict': 'spamVerdict',
        'virus_verdict': 'virusVerdict',
        'spf_verdict': 'spfVerdict',
        'dkim_verdict': 'dkimVerdict',
        'dmarc_verdict': 'dmarcVerdict'
    }

    def __init__(self, spam_verdict=None, virus_verdict=None, spf_verdict=None, dkim_verdict=None, dmarc_verdict=None, local_vars_configuration=None):  # noqa: E501
        """EmailAnalysis - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._spam_verdict = None
        self._virus_verdict = None
        self._spf_verdict = None
        self._dkim_verdict = None
        self._dmarc_verdict = None
        self.discriminator = None

        self.spam_verdict = spam_verdict
        self.virus_verdict = virus_verdict
        self.spf_verdict = spf_verdict
        self.dkim_verdict = dkim_verdict
        self.dmarc_verdict = dmarc_verdict

    @property
    def spam_verdict(self):
        """Gets the spam_verdict of this EmailAnalysis.  # noqa: E501

        Verdict of spam ranking analysis  # noqa: E501

        :return: The spam_verdict of this EmailAnalysis.  # noqa: E501
        :rtype: str
        """
        return self._spam_verdict

    @spam_verdict.setter
    def spam_verdict(self, spam_verdict):
        """Sets the spam_verdict of this EmailAnalysis.

        Verdict of spam ranking analysis  # noqa: E501

        :param spam_verdict: The spam_verdict of this EmailAnalysis.  # noqa: E501
        :type: str
        """

        self._spam_verdict = spam_verdict

    @property
    def virus_verdict(self):
        """Gets the virus_verdict of this EmailAnalysis.  # noqa: E501

        Verdict of virus scan analysis  # noqa: E501

        :return: The virus_verdict of this EmailAnalysis.  # noqa: E501
        :rtype: str
        """
        return self._virus_verdict

    @virus_verdict.setter
    def virus_verdict(self, virus_verdict):
        """Sets the virus_verdict of this EmailAnalysis.

        Verdict of virus scan analysis  # noqa: E501

        :param virus_verdict: The virus_verdict of this EmailAnalysis.  # noqa: E501
        :type: str
        """

        self._virus_verdict = virus_verdict

    @property
    def spf_verdict(self):
        """Gets the spf_verdict of this EmailAnalysis.  # noqa: E501

        Verdict of Send Policy Framework record spoofing analysis  # noqa: E501

        :return: The spf_verdict of this EmailAnalysis.  # noqa: E501
        :rtype: str
        """
        return self._spf_verdict

    @spf_verdict.setter
    def spf_verdict(self, spf_verdict):
        """Sets the spf_verdict of this EmailAnalysis.

        Verdict of Send Policy Framework record spoofing analysis  # noqa: E501

        :param spf_verdict: The spf_verdict of this EmailAnalysis.  # noqa: E501
        :type: str
        """

        self._spf_verdict = spf_verdict

    @property
    def dkim_verdict(self):
        """Gets the dkim_verdict of this EmailAnalysis.  # noqa: E501

        Verdict of DomainKeys Identified Mail analysis  # noqa: E501

        :return: The dkim_verdict of this EmailAnalysis.  # noqa: E501
        :rtype: str
        """
        return self._dkim_verdict

    @dkim_verdict.setter
    def dkim_verdict(self, dkim_verdict):
        """Sets the dkim_verdict of this EmailAnalysis.

        Verdict of DomainKeys Identified Mail analysis  # noqa: E501

        :param dkim_verdict: The dkim_verdict of this EmailAnalysis.  # noqa: E501
        :type: str
        """

        self._dkim_verdict = dkim_verdict

    @property
    def dmarc_verdict(self):
        """Gets the dmarc_verdict of this EmailAnalysis.  # noqa: E501

        Verdict of Domain-based Message Authentication Reporting and Conformance analysis  # noqa: E501

        :return: The dmarc_verdict of this EmailAnalysis.  # noqa: E501
        :rtype: str
        """
        return self._dmarc_verdict

    @dmarc_verdict.setter
    def dmarc_verdict(self, dmarc_verdict):
        """Sets the dmarc_verdict of this EmailAnalysis.

        Verdict of Domain-based Message Authentication Reporting and Conformance analysis  # noqa: E501

        :param dmarc_verdict: The dmarc_verdict of this EmailAnalysis.  # noqa: E501
        :type: str
        """

        self._dmarc_verdict = dmarc_verdict

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, EmailAnalysis):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, EmailAnalysis):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/email.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class Email(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'inbox_id': 'str',
        'domain_id': 'str',
        'to': 'list[str]',
        '_from': 'str',
        'sender': 'Sender',
        'recipients': 'EmailRecipients',
        'reply_to': 'str',
        'cc': 'list[str]',
        'bcc': 'list[str]',
        'headers': 'dict(str, str)',
        'headers_map': 'dict(str, list[str])',
        'attachments': 'list[str]',
        'subject': 'str',
        'body': 'str',
        'body_excerpt': 'str',
        'text_excerpt': 'str',
        'body_md5_hash': 'str',
        'is_html': 'bool',
        'charset': 'str',
        'analysis': 'EmailAnalysis',
        'created_at': 'datetime',
        'updated_at': 'datetime',
        'read': 'bool',
        'team_access': 'bool',
        'is_x_amp_html': 'bool',
        'body_part_content_types': 'list[str]',
        'html': 'bool',
        'xamp_html': 'bool'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'inbox_id': 'inboxId',
        'domain_id': 'domainId',
        'to': 'to',
        '_from': 'from',
        'sender': 'sender',
        'recipients': 'recipients',
        'reply_to': 'replyTo',
        'cc': 'cc',
        'bcc': 'bcc',
        'headers': 'headers',
        'headers_map': 'headersMap',
        'attachments': 'attachments',
        'subject': 'subject',
        'body': 'body',
        'body_excerpt': 'bodyExcerpt',
        'text_excerpt': 'textExcerpt',
        'body_md5_hash': 'bodyMD5Hash',
        'is_html': 'isHTML',
        'charset': 'charset',
        'analysis': 'analysis',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt',
        'read': 'read',
        'team_access': 'teamAccess',
        'is_x_amp_html': 'isXAmpHtml',
        'body_part_content_types': 'bodyPartContentTypes',
        'html': 'html',
        'xamp_html': 'xampHtml'
    }

    def __init__(self, id=None, user_id=None, inbox_id=None, domain_id=None, to=None, _from=None, sender=None, recipients=None, reply_to=None, cc=None, bcc=None, headers=None, headers_map=None, attachments=None, subject=None, body=None, body_excerpt=None, text_excerpt=None, body_md5_hash=None, is_html=None, charset=None, analysis=None, created_at=None, updated_at=None, read=None, team_access=None, is_x_amp_html=None, body_part_content_types=None, html=None, xamp_html=None, local_vars_configuration=None):  # noqa: E501
        """Email - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._inbox_id = None
        self._domain_id = None
        self._to = None
        self.__from = None
        self._sender = None
        self._recipients = None
        self._reply_to = None
        self._cc = None
        self._bcc = None
        self._headers = None
        self._headers_map = None
        self._attachments = None
        self._subject = None
        self._body = None
        self._body_excerpt = None
        self._text_excerpt = None
        self._body_md5_hash = None
        self._is_html = None
        self._charset = None
        self._analysis = None
        self._created_at = None
        self._updated_at = None
        self._read = None
        self._team_access = None
        self._is_x_amp_html = None
        self._body_part_content_types = None
        self._html = None
        self._xamp_html = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        self.inbox_id = inbox_id
        self.domain_id = domain_id
        self.to = to
        self._from = _from
        self.sender = sender
        self.recipients = recipients
        self.reply_to = reply_to
        self.cc = cc
        self.bcc = bcc
        self.headers = headers
        self.headers_map = headers_map
        self.attachments = attachments
        self.subject = subject
        self.body = body
        self.body_excerpt = body_excerpt
        self.text_excerpt = text_excerpt
        self.body_md5_hash = body_md5_hash
        self.is_html = is_html
        self.charset = charset
        self.analysis = analysis
        self.created_at = created_at
        self.updated_at = updated_at
        self.read = read
        self.team_access = team_access
        self.is_x_amp_html = is_x_amp_html
        self.body_part_content_types = body_part_content_types
        if html is not None:
            self.html = html
        if xamp_html is not None:
            self.xamp_html = xamp_html

    @property
    def id(self):
        """Gets the id of this Email.  # noqa: E501

        ID of the email entity  # noqa: E501

        :return: The id of this Email.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this Email.

        ID of the email entity  # noqa: E501

        :param id: The id of this Email.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this Email.  # noqa: E501

        ID of user that email belongs to  # noqa: E501

        :return: The user_id of this Email.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this Email.

        ID of user that email belongs to  # noqa: E501

        :param user_id: The user_id of this Email.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def inbox_id(self):
        """Gets the inbox_id of this Email.  # noqa: E501

        ID of the inbox that received the email  # noqa: E501

        :return: The inbox_id of this Email.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this Email.

        ID of the inbox that received the email  # noqa: E501

        :param inbox_id: The inbox_id of this Email.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def domain_id(self):
        """Gets the domain_id of this Email.  # noqa: E501

        ID of the domain that received the email  # noqa: E501

        :return: The domain_id of this Email.  # noqa: E501
        :rtype: str
        """
        return self._domain_id

    @domain_id.setter
    def domain_id(self, domain_id):
        """Sets the domain_id of this Email.

        ID of the domain that received the email  # noqa: E501

        :param domain_id: The domain_id of this Email.  # noqa: E501
        :type: str
        """

        self._domain_id = domain_id

    @property
    def to(self):
        """Gets the to of this Email.  # noqa: E501

        List of `To` recipient email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :return: The to of this Email.  # noqa: E501
        :rtype: list[str]
        """
        return self._to

    @to.setter
    def to(self, to):
        """Sets the to of this Email.

        List of `To` recipient email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :param to: The to of this Email.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and to is None:  # noqa: E501
            raise ValueError("Invalid value for `to`, must not be `None`")  # noqa: E501

        self._to = to

    @property
    def _from(self):
        """Gets the _from of this Email.  # noqa: E501

        Who the email was sent from. An email address - see fromName for the sender name.  # noqa: E501

        :return: The _from of this Email.  # noqa: E501
        :rtype: str
        """
        return self.__from

    @_from.setter
    def _from(self, _from):
        """Sets the _from of this Email.

        Who the email was sent from. An email address - see fromName for the sender name.  # noqa: E501

        :param _from: The _from of this Email.  # noqa: E501
        :type: str
        """

        self.__from = _from

    @property
    def sender(self):
        """Gets the sender of this Email.  # noqa: E501


        :return: The sender of this Email.  # noqa: E501
        :rtype: Sender
        """
        return self._sender

    @sender.setter
    def sender(self, sender):
        """Sets the sender of this Email.


        :param sender: The sender of this Email.  # noqa: E501
        :type: Sender
        """

        self._sender = sender

    @property
    def recipients(self):
        """Gets the recipients of this Email.  # noqa: E501


        :return: The recipients of this Email.  # noqa: E501
        :rtype: EmailRecipients
        """
        return self._recipients

    @recipients.setter
    def recipients(self, recipients):
        """Sets the recipients of this Email.


        :param recipients: The recipients of this Email.  # noqa: E501
        :type: EmailRecipients
        """

        self._recipients = recipients

    @property
    def reply_to(self):
        """Gets the reply_to of this Email.  # noqa: E501

        The `replyTo` field on the received email message  # noqa: E501

        :return: The reply_to of this Email.  # noqa: E501
        :rtype: str
        """
        return self._reply_to

    @reply_to.setter
    def reply_to(self, reply_to):
        """Sets the reply_to of this Email.

        The `replyTo` field on the received email message  # noqa: E501

        :param reply_to: The reply_to of this Email.  # noqa: E501
        :type: str
        """

        self._reply_to = reply_to

    @property
    def cc(self):
        """Gets the cc of this Email.  # noqa: E501

        List of `CC` recipients email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :return: The cc of this Email.  # noqa: E501
        :rtype: list[str]
        """
        return self._cc

    @cc.setter
    def cc(self, cc):
        """Sets the cc of this Email.

        List of `CC` recipients email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :param cc: The cc of this Email.  # noqa: E501
        :type: list[str]
        """

        self._cc = cc

    @property
    def bcc(self):
        """Gets the bcc of this Email.  # noqa: E501

        List of `BCC` recipients email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :return: The bcc of this Email.  # noqa: E501
        :rtype: list[str]
        """
        return self._bcc

    @bcc.setter
    def bcc(self, bcc):
        """Sets the bcc of this Email.

        List of `BCC` recipients email addresses that the email was addressed to. See recipients object for names.  # noqa: E501

        :param bcc: The bcc of this Email.  # noqa: E501
        :type: list[str]
        """

        self._bcc = bcc

    @property
    def headers(self):
        """Gets the headers of this Email.  # noqa: E501

        Collection of SMTP headers attached to email  # noqa: E501

        :return: The headers of this Email.  # noqa: E501
        :rtype: dict(str, str)
        """
        return self._headers

    @headers.setter
    def headers(self, headers):
        """Sets the headers of this Email.

        Collection of SMTP headers attached to email  # noqa: E501

        :param headers: The headers of this Email.  # noqa: E501
        :type: dict(str, str)
        """

        self._headers = headers

    @property
    def headers_map(self):
        """Gets the headers_map of this Email.  # noqa: E501

        Multi-value map of SMTP headers attached to email  # noqa: E501

        :return: The headers_map of this Email.  # noqa: E501
        :rtype: dict(str, list[str])
        """
        return self._headers_map

    @headers_map.setter
    def headers_map(self, headers_map):
        """Sets the headers_map of this Email.

        Multi-value map of SMTP headers attached to email  # noqa: E501

        :param headers_map: The headers_map of this Email.  # noqa: E501
        :type: dict(str, list[str])
        """

        self._headers_map = headers_map

    @property
    def attachments(self):
        """Gets the attachments of this Email.  # noqa: E501

        List of IDs of attachments found in the email. Use these IDs with the Inbox and Email Controllers to download attachments and attachment meta data such as filesize, name, extension.  # noqa: E501

        :return: The attachments of this Email.  # noqa: E501
        :rtype: list[str]
        """
        return self._attachments

    @attachments.setter
    def attachments(self, attachments):
        """Sets the attachments of this Email.

        List of IDs of attachments found in the email. Use these IDs with the Inbox and Email Controllers to download attachments and attachment meta data such as filesize, name, extension.  # noqa: E501

        :param attachments: The attachments of this Email.  # noqa: E501
        :type: list[str]
        """

        self._attachments = attachments

    @property
    def subject(self):
        """Gets the subject of this Email.  # noqa: E501

        The subject line of the email message as specified by SMTP subject header  # noqa: E501

        :return: The subject of this Email.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this Email.

        The subject line of the email message as specified by SMTP subject header  # noqa: E501

        :param subject: The subject of this Email.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def body(self):
        """Gets the body of this Email.  # noqa: E501

        The body of the email message as text parsed from the SMTP message body (does not include attachments). Fetch the raw content to access the SMTP message and use the attachments property to access attachments. The body is stored separately to the email entity so the body is not returned in paginated results only in full single email or wait requests.  # noqa: E501

        :return: The body of this Email.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this Email.

        The body of the email message as text parsed from the SMTP message body (does not include attachments). Fetch the raw content to access the SMTP message and use the attachments property to access attachments. The body is stored separately to the email entity so the body is not returned in paginated results only in full single email or wait requests.  # noqa: E501

        :param body: The body of this Email.  # noqa: E501
        :type: str
        """

        self._body = body

    @property
    def body_excerpt(self):
        """Gets the body_excerpt of this Email.  # noqa: E501

        An excerpt of the body of the email message for quick preview. Takes HTML content part if exists falls back to TEXT content part if not  # noqa: E501

        :return: The body_excerpt of this Email.  # noqa: E501
        :rtype: str
        """
        return self._body_excerpt

    @body_excerpt.setter
    def body_excerpt(self, body_excerpt):
        """Sets the body_excerpt of this Email.

        An excerpt of the body of the email message for quick preview. Takes HTML content part if exists falls back to TEXT content part if not  # noqa: E501

        :param body_excerpt: The body_excerpt of this Email.  # noqa: E501
        :type: str
        """

        self._body_excerpt = body_excerpt

    @property
    def text_excerpt(self):
        """Gets the text_excerpt of this Email.  # noqa: E501

        An excerpt of the body of the email message for quick preview. Takes TEXT content part if exists  # noqa: E501

        :return: The text_excerpt of this Email.  # noqa: E501
        :rtype: str
        """
        return self._text_excerpt

    @text_excerpt.setter
    def text_excerpt(self, text_excerpt):
        """Sets the text_excerpt of this Email.

        An excerpt of the body of the email message for quick preview. Takes TEXT content part if exists  # noqa: E501

        :param text_excerpt: The text_excerpt of this Email.  # noqa: E501
        :type: str
        """

        self._text_excerpt = text_excerpt

    @property
    def body_md5_hash(self):
        """Gets the body_md5_hash of this Email.  # noqa: E501

        A hash signature of the email message using MD5. Useful for comparing emails without fetching full body.  # noqa: E501

        :return: The body_md5_hash of this Email.  # noqa: E501
        :rtype: str
        """
        return self._body_md5_hash

    @body_md5_hash.setter
    def body_md5_hash(self, body_md5_hash):
        """Sets the body_md5_hash of this Email.

        A hash signature of the email message using MD5. Useful for comparing emails without fetching full body.  # noqa: E501

        :param body_md5_hash: The body_md5_hash of this Email.  # noqa: E501
        :type: str
        """

        self._body_md5_hash = body_md5_hash

    @property
    def is_html(self):
        """Gets the is_html of this Email.  # noqa: E501

        Is the email body content type HTML?  # noqa: E501

        :return: The is_html of this Email.  # noqa: E501
        :rtype: bool
        """
        return self._is_html

    @is_html.setter
    def is_html(self, is_html):
        """Sets the is_html of this Email.

        Is the email body content type HTML?  # noqa: E501

        :param is_html: The is_html of this Email.  # noqa: E501
        :type: bool
        """

        self._is_html = is_html

    @property
    def charset(self):
        """Gets the charset of this Email.  # noqa: E501

        Detected character set of the email body such as UTF-8  # noqa: E501

        :return: The charset of this Email.  # noqa: E501
        :rtype: str
        """
        return self._charset

    @charset.setter
    def charset(self, charset):
        """Sets the charset of this Email.

        Detected character set of the email body such as UTF-8  # noqa: E501

        :param charset: The charset of this Email.  # noqa: E501
        :type: str
        """

        self._charset = charset

    @property
    def analysis(self):
        """Gets the analysis of this Email.  # noqa: E501


        :return: The analysis of this Email.  # noqa: E501
        :rtype: EmailAnalysis
        """
        return self._analysis

    @analysis.setter
    def analysis(self, analysis):
        """Sets the analysis of this Email.


        :param analysis: The analysis of this Email.  # noqa: E501
        :type: EmailAnalysis
        """

        self._analysis = analysis

    @property
    def created_at(self):
        """Gets the created_at of this Email.  # noqa: E501

        When was the email received by MailSlurp  # noqa: E501

        :return: The created_at of this Email.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this Email.

        When was the email received by MailSlurp  # noqa: E501

        :param created_at: The created_at of this Email.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this Email.  # noqa: E501

        When was the email last updated  # noqa: E501

        :return: The updated_at of this Email.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this Email.

        When was the email last updated  # noqa: E501

        :param updated_at: The updated_at of this Email.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    @property
    def read(self):
        """Gets the read of this Email.  # noqa: E501

        Read flag. Has the email ever been viewed in the dashboard or fetched via the API with a hydrated body? If so the email is marked as read. Paginated results do not affect read status. Read status is different to email opened event as it depends on your own account accessing the email. Email opened is determined by tracking pixels sent to other uses if enable during sending. You can listened for both email read and email opened events using webhooks.  # noqa: E501

        :return: The read of this Email.  # noqa: E501
        :rtype: bool
        """
        return self._read

    @read.setter
    def read(self, read):
        """Sets the read of this Email.

        Read flag. Has the email ever been viewed in the dashboard or fetched via the API with a hydrated body? If so the email is marked as read. Paginated results do not affect read status. Read status is different to email opened event as it depends on your own account accessing the email. Email opened is determined by tracking pixels sent to other uses if enable during sending. You can listened for both email read and email opened events using webhooks.  # noqa: E501

        :param read: The read of this Email.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and read is None:  # noqa: E501
            raise ValueError("Invalid value for `read`, must not be `None`")  # noqa: E501

        self._read = read

    @property
    def team_access(self):
        """Gets the team_access of this Email.  # noqa: E501

        Can the email be accessed by organization team members  # noqa: E501

        :return: The team_access of this Email.  # noqa: E501
        :rtype: bool
        """
        return self._team_access

    @team_access.setter
    def team_access(self, team_access):
        """Sets the team_access of this Email.

        Can the email be accessed by organization team members  # noqa: E501

        :param team_access: The team_access of this Email.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and team_access is None:  # noqa: E501
            raise ValueError("Invalid value for `team_access`, must not be `None`")  # noqa: E501

        self._team_access = team_access

    @property
    def is_x_amp_html(self):
        """Gets the is_x_amp_html of this Email.  # noqa: E501

        Is the email body content type x-amp-html Amp4Email?  # noqa: E501

        :return: The is_x_amp_html of this Email.  # noqa: E501
        :rtype: bool
        """
        return self._is_x_amp_html

    @is_x_amp_html.setter
    def is_x_amp_html(self, is_x_amp_html):
        """Sets the is_x_amp_html of this Email.

        Is the email body content type x-amp-html Amp4Email?  # noqa: E501

        :param is_x_amp_html: The is_x_amp_html of this Email.  # noqa: E501
        :type: bool
        """

        self._is_x_amp_html = is_x_amp_html

    @property
    def body_part_content_types(self):
        """Gets the body_part_content_types of this Email.  # noqa: E501

        A list of detected multipart mime message body part content types such as text/plain and text/html. Can be used with email bodyPart endpoints to fetch individual body parts.  # noqa: E501

        :return: The body_part_content_types of this Email.  # noqa: E501
        :rtype: list[str]
        """
        return self._body_part_content_types

    @body_part_content_types.setter
    def body_part_content_types(self, body_part_content_types):
        """Sets the body_part_content_types of this Email.

        A list of detected multipart mime message body part content types such as text/plain and text/html. Can be used with email bodyPart endpoints to fetch individual body parts.  # noqa: E501

        :param body_part_content_types: The body_part_content_types of this Email.  # noqa: E501
        :type: list[str]
        """

        self._body_part_content_types = body_part_content_types

    @property
    def html(self):
        """Gets the html of this Email.  # noqa: E501


        :return: The html of this Email.  # noqa: E501
        :rtype: bool
        """
        return self._html

    @html.setter
    def html(self, html):
        """Sets the html of this Email.


        :param html: The html of this Email.  # noqa: E501
        :type: bool
        """

        self._html = html

    @property
    def xamp_html(self):
        """Gets the xamp_html of this Email.  # noqa: E501


        :return: The xamp_html of this Email.  # noqa: E501
        :rtype: bool
        """
        return self._xamp_html

    @xamp_html.setter
    def xamp_html(self, xamp_html):
        """Sets the xamp_html of this Email.


        :param xamp_html: The xamp_html of this Email.  # noqa: E501
        :type: bool
        """

        self._xamp_html = xamp_html

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, Email):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, Email):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/download_attachment_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class DownloadAttachmentDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'base64_file_contents': 'str',
        'content_type': 'str',
        'size_bytes': 'int'
    }

    attribute_map = {
        'base64_file_contents': 'base64FileContents',
        'content_type': 'contentType',
        'size_bytes': 'sizeBytes'
    }

    def __init__(self, base64_file_contents=None, content_type=None, size_bytes=None, local_vars_configuration=None):  # noqa: E501
        """DownloadAttachmentDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._base64_file_contents = None
        self._content_type = None
        self._size_bytes = None
        self.discriminator = None

        self.base64_file_contents = base64_file_contents
        self.content_type = content_type
        self.size_bytes = size_bytes

    @property
    def base64_file_contents(self):
        """Gets the base64_file_contents of this DownloadAttachmentDto.  # noqa: E501

        Base64 encoded string of attachment bytes. Decode the base64 encoded string to get the raw contents. If the file has a content type such as `text/html` you can read the contents directly by converting it to string using `utf-8` encoding.  # noqa: E501

        :return: The base64_file_contents of this DownloadAttachmentDto.  # noqa: E501
        :rtype: str
        """
        return self._base64_file_contents

    @base64_file_contents.setter
    def base64_file_contents(self, base64_file_contents):
        """Sets the base64_file_contents of this DownloadAttachmentDto.

        Base64 encoded string of attachment bytes. Decode the base64 encoded string to get the raw contents. If the file has a content type such as `text/html` you can read the contents directly by converting it to string using `utf-8` encoding.  # noqa: E501

        :param base64_file_contents: The base64_file_contents of this DownloadAttachmentDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and base64_file_contents is None:  # noqa: E501
            raise ValueError("Invalid value for `base64_file_contents`, must not be `None`")  # noqa: E501

        self._base64_file_contents = base64_file_contents

    @property
    def content_type(self):
        """Gets the content_type of this DownloadAttachmentDto.  # noqa: E501

        Content type of attachment. Examples are `image/png`, `application/msword`, `text/csv` etc.  # noqa: E501

        :return: The content_type of this DownloadAttachmentDto.  # noqa: E501
        :rtype: str
        """
        return self._content_type

    @content_type.setter
    def content_type(self, content_type):
        """Sets the content_type of this DownloadAttachmentDto.

        Content type of attachment. Examples are `image/png`, `application/msword`, `text/csv` etc.  # noqa: E501

        :param content_type: The content_type of this DownloadAttachmentDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and content_type is None:  # noqa: E501
            raise ValueError("Invalid value for `content_type`, must not be `None`")  # noqa: E501

        self._content_type = content_type

    @property
    def size_bytes(self):
        """Gets the size_bytes of this DownloadAttachmentDto.  # noqa: E501

        Size in bytes of attachment content  # noqa: E501

        :return: The size_bytes of this DownloadAttachmentDto.  # noqa: E501
        :rtype: int
        """
        return self._size_bytes

    @size_bytes.setter
    def size_bytes(self, size_bytes):
        """Sets the size_bytes of this DownloadAttachmentDto.

        Size in bytes of attachment content  # noqa: E501

        :param size_bytes: The size_bytes of this DownloadAttachmentDto.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and size_bytes is None:  # noqa: E501
            raise ValueError("Invalid value for `size_bytes`, must not be `None`")  # noqa: E501

        self._size_bytes = size_bytes

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, DownloadAttachmentDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, DownloadAttachmentDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/domain_preview.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class DomainPreview(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'domain': 'str',
        'catch_all_inbox_id': 'str',
        'created_at': 'datetime',
        'domain_type': 'str',
        'is_verified': 'bool',
        'has_missing_records': 'bool'
    }

    attribute_map = {
        'id': 'id',
        'domain': 'domain',
        'catch_all_inbox_id': 'catchAllInboxId',
        'created_at': 'createdAt',
        'domain_type': 'domainType',
        'is_verified': 'isVerified',
        'has_missing_records': 'hasMissingRecords'
    }

    def __init__(self, id=None, domain=None, catch_all_inbox_id=None, created_at=None, domain_type=None, is_verified=None, has_missing_records=None, local_vars_configuration=None):  # noqa: E501
        """DomainPreview - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._domain = None
        self._catch_all_inbox_id = None
        self._created_at = None
        self._domain_type = None
        self._is_verified = None
        self._has_missing_records = None
        self.discriminator = None

        self.id = id
        self.domain = domain
        self.catch_all_inbox_id = catch_all_inbox_id
        self.created_at = created_at
        self.domain_type = domain_type
        self.is_verified = is_verified
        self.has_missing_records = has_missing_records

    @property
    def id(self):
        """Gets the id of this DomainPreview.  # noqa: E501


        :return: The id of this DomainPreview.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this DomainPreview.


        :param id: The id of this DomainPreview.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def domain(self):
        """Gets the domain of this DomainPreview.  # noqa: E501


        :return: The domain of this DomainPreview.  # noqa: E501
        :rtype: str
        """
        return self._domain

    @domain.setter
    def domain(self, domain):
        """Sets the domain of this DomainPreview.


        :param domain: The domain of this DomainPreview.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and domain is None:  # noqa: E501
            raise ValueError("Invalid value for `domain`, must not be `None`")  # noqa: E501

        self._domain = domain

    @property
    def catch_all_inbox_id(self):
        """Gets the catch_all_inbox_id of this DomainPreview.  # noqa: E501


        :return: The catch_all_inbox_id of this DomainPreview.  # noqa: E501
        :rtype: str
        """
        return self._catch_all_inbox_id

    @catch_all_inbox_id.setter
    def catch_all_inbox_id(self, catch_all_inbox_id):
        """Sets the catch_all_inbox_id of this DomainPreview.


        :param catch_all_inbox_id: The catch_all_inbox_id of this DomainPreview.  # noqa: E501
        :type: str
        """

        self._catch_all_inbox_id = catch_all_inbox_id

    @property
    def created_at(self):
        """Gets the created_at of this DomainPreview.  # noqa: E501


        :return: The created_at of this DomainPreview.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this DomainPreview.


        :param created_at: The created_at of this DomainPreview.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def domain_type(self):
        """Gets the domain_type of this DomainPreview.  # noqa: E501

        Type of domain. Dictates type of inbox that can be created with domain. HTTP means inboxes are processed using SES while SMTP inboxes use a custom SMTP mail server. SMTP does not support sending so use HTTP for sending emails.  # noqa: E501

        :return: The domain_type of this DomainPreview.  # noqa: E501
        :rtype: str
        """
        return self._domain_type

    @domain_type.setter
    def domain_type(self, domain_type):
        """Sets the domain_type of this DomainPreview.

        Type of domain. Dictates type of inbox that can be created with domain. HTTP means inboxes are processed using SES while SMTP inboxes use a custom SMTP mail server. SMTP does not support sending so use HTTP for sending emails.  # noqa: E501

        :param domain_type: The domain_type of this DomainPreview.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and domain_type is None:  # noqa: E501
            raise ValueError("Invalid value for `domain_type`, must not be `None`")  # noqa: E501
        allowed_values = ["HTTP_INBOX", "SMTP_DOMAIN"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and domain_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `domain_type` ({0}), must be one of {1}"  # noqa: E501
                .format(domain_type, allowed_values)
            )

        self._domain_type = domain_type

    @property
    def is_verified(self):
        """Gets the is_verified of this DomainPreview.  # noqa: E501


        :return: The is_verified of this DomainPreview.  # noqa: E501
        :rtype: bool
        """
        return self._is_verified

    @is_verified.setter
    def is_verified(self, is_verified):
        """Sets the is_verified of this DomainPreview.


        :param is_verified: The is_verified of this DomainPreview.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and is_verified is None:  # noqa: E501
            raise ValueError("Invalid value for `is_verified`, must not be `None`")  # noqa: E501

        self._is_verified = is_verified

    @property
    def has_missing_records(self):
        """Gets the has_missing_records of this DomainPreview.  # noqa: E501


        :return: The has_missing_records of this DomainPreview.  # noqa: E501
        :rtype: bool
        """
        return self._has_missing_records

    @has_missing_records.setter
    def has_missing_records(self, has_missing_records):
        """Sets the has_missing_records of this DomainPreview.


        :param has_missing_records: The has_missing_records of this DomainPreview.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and has_missing_records is None:  # noqa: E501
            raise ValueError("Invalid value for `has_missing_records`, must not be `None`")  # noqa: E501

        self._has_missing_records = has_missing_records

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, DomainPreview):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, DomainPreview):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/domain_name_record.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class DomainNameRecord(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'label': 'str',
        'required': 'bool',
        'record_type': 'str',
        'name': 'str',
        'record_entries': 'list[str]',
        'ttl': 'int',
        'alternative_record_entries': 'list[str]'
    }

    attribute_map = {
        'label': 'label',
        'required': 'required',
        'record_type': 'recordType',
        'name': 'name',
        'record_entries': 'recordEntries',
        'ttl': 'ttl',
        'alternative_record_entries': 'alternativeRecordEntries'
    }

    def __init__(self, label=None, required=None, record_type=None, name=None, record_entries=None, ttl=None, alternative_record_entries=None, local_vars_configuration=None):  # noqa: E501
        """DomainNameRecord - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._label = None
        self._required = None
        self._record_type = None
        self._name = None
        self._record_entries = None
        self._ttl = None
        self._alternative_record_entries = None
        self.discriminator = None

        self.label = label
        self.required = required
        self.record_type = record_type
        self.name = name
        self.record_entries = record_entries
        self.ttl = ttl
        self.alternative_record_entries = alternative_record_entries

    @property
    def label(self):
        """Gets the label of this DomainNameRecord.  # noqa: E501

        Domain Name Server Record Label  # noqa: E501

        :return: The label of this DomainNameRecord.  # noqa: E501
        :rtype: str
        """
        return self._label

    @label.setter
    def label(self, label):
        """Sets the label of this DomainNameRecord.

        Domain Name Server Record Label  # noqa: E501

        :param label: The label of this DomainNameRecord.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and label is None:  # noqa: E501
            raise ValueError("Invalid value for `label`, must not be `None`")  # noqa: E501
        allowed_values = ["VERIFICATION", "MX", "SPF", "DKIM", "DMARC"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and label not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `label` ({0}), must be one of {1}"  # noqa: E501
                .format(label, allowed_values)
            )

        self._label = label

    @property
    def required(self):
        """Gets the required of this DomainNameRecord.  # noqa: E501


        :return: The required of this DomainNameRecord.  # noqa: E501
        :rtype: bool
        """
        return self._required

    @required.setter
    def required(self, required):
        """Sets the required of this DomainNameRecord.


        :param required: The required of this DomainNameRecord.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and required is None:  # noqa: E501
            raise ValueError("Invalid value for `required`, must not be `None`")  # noqa: E501

        self._required = required

    @property
    def record_type(self):
        """Gets the record_type of this DomainNameRecord.  # noqa: E501

        Domain Name Server Record Types  # noqa: E501

        :return: The record_type of this DomainNameRecord.  # noqa: E501
        :rtype: str
        """
        return self._record_type

    @record_type.setter
    def record_type(self, record_type):
        """Sets the record_type of this DomainNameRecord.

        Domain Name Server Record Types  # noqa: E501

        :param record_type: The record_type of this DomainNameRecord.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and record_type is None:  # noqa: E501
            raise ValueError("Invalid value for `record_type`, must not be `None`")  # noqa: E501
        allowed_values = ["A", "NS", "MD", "MF", "CNAME", "SOA", "MB", "MG", "MR", "NULL", "WKS", "PTR", "HINFO", "MINFO", "MX", "TXT", "RP", "AFSDB", "X25", "ISDN", "RT", "NSAP", "NSAP_PTR", "SIG", "KEY", "PX", "GPOS", "AAAA", "LOC", "NXT", "EID", "NIMLOC", "SRV", "ATMA", "NAPTR", "KX", "CERT", "A6", "DNAME", "SINK", "OPT", "APL", "DS", "SSHFP", "IPSECKEY", "RRSIG", "NSEC", "DNSKEY", "DHCID", "NSEC3", "NSEC3PARAM", "TLSA", "SMIMEA", "HIP", "NINFO", "RKEY", "TALINK", "CDS", "CDNSKEY", "OPENPGPKEY", "CSYNC", "ZONEMD", "SVCB", "HTTPS", "SPF", "UINFO", "UID", "GID", "UNSPEC", "NID", "L32", "L64", "LP", "EUI48", "EUI64", "TKEY", "TSIG", "IXFR", "AXFR", "MAILB", "MAILA", "ANY", "URI", "CAA", "AVC", "DOA", "AMTRELAY", "TA", "DLV"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and record_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `record_type` ({0}), must be one of {1}"  # noqa: E501
                .format(record_type, allowed_values)
            )

        self._record_type = record_type

    @property
    def name(self):
        """Gets the name of this DomainNameRecord.  # noqa: E501


        :return: The name of this DomainNameRecord.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this DomainNameRecord.


        :param name: The name of this DomainNameRecord.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    @property
    def record_entries(self):
        """Gets the record_entries of this DomainNameRecord.  # noqa: E501


        :return: The record_entries of this DomainNameRecord.  # noqa: E501
        :rtype: list[str]
        """
        return self._record_entries

    @record_entries.setter
    def record_entries(self, record_entries):
        """Sets the record_entries of this DomainNameRecord.


        :param record_entries: The record_entries of this DomainNameRecord.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and record_entries is None:  # noqa: E501
            raise ValueError("Invalid value for `record_entries`, must not be `None`")  # noqa: E501

        self._record_entries = record_entries

    @property
    def ttl(self):
        """Gets the ttl of this DomainNameRecord.  # noqa: E501


        :return: The ttl of this DomainNameRecord.  # noqa: E501
        :rtype: int
        """
        return self._ttl

    @ttl.setter
    def ttl(self, ttl):
        """Sets the ttl of this DomainNameRecord.


        :param ttl: The ttl of this DomainNameRecord.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and ttl is None:  # noqa: E501
            raise ValueError("Invalid value for `ttl`, must not be `None`")  # noqa: E501

        self._ttl = ttl

    @property
    def alternative_record_entries(self):
        """Gets the alternative_record_entries of this DomainNameRecord.  # noqa: E501


        :return: The alternative_record_entries of this DomainNameRecord.  # noqa: E501
        :rtype: list[str]
        """
        return self._alternative_record_entries

    @alternative_record_entries.setter
    def alternative_record_entries(self, alternative_record_entries):
        """Sets the alternative_record_entries of this DomainNameRecord.


        :param alternative_record_entries: The alternative_record_entries of this DomainNameRecord.  # noqa: E501
        :type: list[str]
        """

        self._alternative_record_entries = alternative_record_entries

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, DomainNameRecord):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, DomainNameRecord):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/domain_issues_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class DomainIssuesDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'has_issues': 'bool'
    }

    attribute_map = {
        'has_issues': 'hasIssues'
    }

    def __init__(self, has_issues=None, local_vars_configuration=None):  # noqa: E501
        """DomainIssuesDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._has_issues = None
        self.discriminator = None

        self.has_issues = has_issues

    @property
    def has_issues(self):
        """Gets the has_issues of this DomainIssuesDto.  # noqa: E501


        :return: The has_issues of this DomainIssuesDto.  # noqa: E501
        :rtype: bool
        """
        return self._has_issues

    @has_issues.setter
    def has_issues(self, has_issues):
        """Sets the has_issues of this DomainIssuesDto.


        :param has_issues: The has_issues of this DomainIssuesDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and has_issues is None:  # noqa: E501
            raise ValueError("Invalid value for `has_issues`, must not be `None`")  # noqa: E501

        self._has_issues = has_issues

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, DomainIssuesDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, DomainIssuesDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/domain_information.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class DomainInformation(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'domain_name': 'str',
        'verified': 'bool',
        'domain_type': 'str'
    }

    attribute_map = {
        'domain_name': 'domainName',
        'verified': 'verified',
        'domain_type': 'domainType'
    }

    def __init__(self, domain_name=None, verified=None, domain_type=None, local_vars_configuration=None):  # noqa: E501
        """DomainInformation - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._domain_name = None
        self._verified = None
        self._domain_type = None
        self.discriminator = None

        self.domain_name = domain_name
        self.verified = verified
        self.domain_type = domain_type

    @property
    def domain_name(self):
        """Gets the domain_name of this DomainInformation.  # noqa: E501


        :return: The domain_name of this DomainInformation.  # noqa: E501
        :rtype: str
        """
        return self._domain_name

    @domain_name.setter
    def domain_name(self, domain_name):
        """Sets the domain_name of this DomainInformation.


        :param domain_name: The domain_name of this DomainInformation.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and domain_name is None:  # noqa: E501
            raise ValueError("Invalid value for `domain_name`, must not be `None`")  # noqa: E501

        self._domain_name = domain_name

    @property
    def verified(self):
        """Gets the verified of this DomainInformation.  # noqa: E501


        :return: The verified of this DomainInformation.  # noqa: E501
        :rtype: bool
        """
        return self._verified

    @verified.setter
    def verified(self, verified):
        """Sets the verified of this DomainInformation.


        :param verified: The verified of this DomainInformation.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and verified is None:  # noqa: E501
            raise ValueError("Invalid value for `verified`, must not be `None`")  # noqa: E501

        self._verified = verified

    @property
    def domain_type(self):
        """Gets the domain_type of this DomainInformation.  # noqa: E501

        Type of domain. Dictates type of inbox that can be created with domain. HTTP means inboxes are processed using SES while SMTP inboxes use a custom SMTP mail server. SMTP does not support sending so use HTTP for sending emails.  # noqa: E501

        :return: The domain_type of this DomainInformation.  # noqa: E501
        :rtype: str
        """
        return self._domain_type

    @domain_type.setter
    def domain_type(self, domain_type):
        """Sets the domain_type of this DomainInformation.

        Type of domain. Dictates type of inbox that can be created with domain. HTTP means inboxes are processed using SES while SMTP inboxes use a custom SMTP mail server. SMTP does not support sending so use HTTP for sending emails.  # noqa: E501

        :param domain_type: The domain_type of this DomainInformation.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and domain_type is None:  # noqa: E501
            raise ValueError("Invalid value for `domain_type`, must not be `None`")  # noqa: E501
        allowed_values = ["HTTP_INBOX", "SMTP_DOMAIN"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and domain_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `domain_type` ({0}), must be one of {1}"  # noqa: E501
                .format(domain_type, allowed_values)
            )

        self._domain_type = domain_type

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, DomainInformation):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, DomainInformation):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/domain_groups_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class DomainGroupsDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'domain_groups': 'list[DomainGroup]'
    }

    attribute_map = {
        'domain_groups': 'domainGroups'
    }

    def __init__(self, domain_groups=None, local_vars_configuration=None):  # noqa: E501
        """DomainGroupsDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._domain_groups = None
        self.discriminator = None

        self.domain_groups = domain_groups

    @property
    def domain_groups(self):
        """Gets the domain_groups of this DomainGroupsDto.  # noqa: E501


        :return: The domain_groups of this DomainGroupsDto.  # noqa: E501
        :rtype: list[DomainGroup]
        """
        return self._domain_groups

    @domain_groups.setter
    def domain_groups(self, domain_groups):
        """Sets the domain_groups of this DomainGroupsDto.


        :param domain_groups: The domain_groups of this DomainGroupsDto.  # noqa: E501
        :type: list[DomainGroup]
        """
        if self.local_vars_configuration.client_side_validation and domain_groups is None:  # noqa: E501
            raise ValueError("Invalid value for `domain_groups`, must not be `None`")  # noqa: E501

        self._domain_groups = domain_groups

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, DomainGroupsDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, DomainGroupsDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/domain_group.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class DomainGroup(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'label': 'str',
        'domains': 'list[DomainInformation]'
    }

    attribute_map = {
        'label': 'label',
        'domains': 'domains'
    }

    def __init__(self, label=None, domains=None, local_vars_configuration=None):  # noqa: E501
        """DomainGroup - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._label = None
        self._domains = None
        self.discriminator = None

        self.label = label
        self.domains = domains

    @property
    def label(self):
        """Gets the label of this DomainGroup.  # noqa: E501


        :return: The label of this DomainGroup.  # noqa: E501
        :rtype: str
        """
        return self._label

    @label.setter
    def label(self, label):
        """Sets the label of this DomainGroup.


        :param label: The label of this DomainGroup.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and label is None:  # noqa: E501
            raise ValueError("Invalid value for `label`, must not be `None`")  # noqa: E501
        allowed_values = ["DEFAULT", "DOMAIN_POOL", "CUSTOM"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and label not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `label` ({0}), must be one of {1}"  # noqa: E501
                .format(label, allowed_values)
            )

        self._label = label

    @property
    def domains(self):
        """Gets the domains of this DomainGroup.  # noqa: E501


        :return: The domains of this DomainGroup.  # noqa: E501
        :rtype: list[DomainInformation]
        """
        return self._domains

    @domains.setter
    def domains(self, domains):
        """Sets the domains of this DomainGroup.


        :param domains: The domains of this DomainGroup.  # noqa: E501
        :type: list[DomainInformation]
        """
        if self.local_vars_configuration.client_side_validation and domains is None:  # noqa: E501
            raise ValueError("Invalid value for `domains`, must not be `None`")  # noqa: E501

        self._domains = domains

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, DomainGroup):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, DomainGroup):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/domain_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class DomainDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'domain': 'str',
        'verification_token': 'str',
        'dkim_tokens': 'list[str]',
        'missing_records_message': 'str',
        'has_missing_records': 'bool',
        'is_verified': 'bool',
        'domain_name_records': 'list[DomainNameRecord]',
        'catch_all_inbox_id': 'str',
        'created_at': 'datetime',
        'updated_at': 'datetime',
        'domain_type': 'str'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'domain': 'domain',
        'verification_token': 'verificationToken',
        'dkim_tokens': 'dkimTokens',
        'missing_records_message': 'missingRecordsMessage',
        'has_missing_records': 'hasMissingRecords',
        'is_verified': 'isVerified',
        'domain_name_records': 'domainNameRecords',
        'catch_all_inbox_id': 'catchAllInboxId',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt',
        'domain_type': 'domainType'
    }

    def __init__(self, id=None, user_id=None, domain=None, verification_token=None, dkim_tokens=None, missing_records_message=None, has_missing_records=None, is_verified=None, domain_name_records=None, catch_all_inbox_id=None, created_at=None, updated_at=None, domain_type=None, local_vars_configuration=None):  # noqa: E501
        """DomainDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._domain = None
        self._verification_token = None
        self._dkim_tokens = None
        self._missing_records_message = None
        self._has_missing_records = None
        self._is_verified = None
        self._domain_name_records = None
        self._catch_all_inbox_id = None
        self._created_at = None
        self._updated_at = None
        self._domain_type = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        self.domain = domain
        self.verification_token = verification_token
        self.dkim_tokens = dkim_tokens
        self.missing_records_message = missing_records_message
        self.has_missing_records = has_missing_records
        self.is_verified = is_verified
        self.domain_name_records = domain_name_records
        self.catch_all_inbox_id = catch_all_inbox_id
        self.created_at = created_at
        self.updated_at = updated_at
        self.domain_type = domain_type

    @property
    def id(self):
        """Gets the id of this DomainDto.  # noqa: E501


        :return: The id of this DomainDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this DomainDto.


        :param id: The id of this DomainDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this DomainDto.  # noqa: E501


        :return: The user_id of this DomainDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this DomainDto.


        :param user_id: The user_id of this DomainDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def domain(self):
        """Gets the domain of this DomainDto.  # noqa: E501

        Custom domain name  # noqa: E501

        :return: The domain of this DomainDto.  # noqa: E501
        :rtype: str
        """
        return self._domain

    @domain.setter
    def domain(self, domain):
        """Sets the domain of this DomainDto.

        Custom domain name  # noqa: E501

        :param domain: The domain of this DomainDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and domain is None:  # noqa: E501
            raise ValueError("Invalid value for `domain`, must not be `None`")  # noqa: E501

        self._domain = domain

    @property
    def verification_token(self):
        """Gets the verification_token of this DomainDto.  # noqa: E501

        Verification tokens  # noqa: E501

        :return: The verification_token of this DomainDto.  # noqa: E501
        :rtype: str
        """
        return self._verification_token

    @verification_token.setter
    def verification_token(self, verification_token):
        """Sets the verification_token of this DomainDto.

        Verification tokens  # noqa: E501

        :param verification_token: The verification_token of this DomainDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and verification_token is None:  # noqa: E501
            raise ValueError("Invalid value for `verification_token`, must not be `None`")  # noqa: E501

        self._verification_token = verification_token

    @property
    def dkim_tokens(self):
        """Gets the dkim_tokens of this DomainDto.  # noqa: E501

        Unique token DKIM tokens  # noqa: E501

        :return: The dkim_tokens of this DomainDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._dkim_tokens

    @dkim_tokens.setter
    def dkim_tokens(self, dkim_tokens):
        """Sets the dkim_tokens of this DomainDto.

        Unique token DKIM tokens  # noqa: E501

        :param dkim_tokens: The dkim_tokens of this DomainDto.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and dkim_tokens is None:  # noqa: E501
            raise ValueError("Invalid value for `dkim_tokens`, must not be `None`")  # noqa: E501

        self._dkim_tokens = dkim_tokens

    @property
    def missing_records_message(self):
        """Gets the missing_records_message of this DomainDto.  # noqa: E501

        If the domain is missing records then show which pairs are missing.  # noqa: E501

        :return: The missing_records_message of this DomainDto.  # noqa: E501
        :rtype: str
        """
        return self._missing_records_message

    @missing_records_message.setter
    def missing_records_message(self, missing_records_message):
        """Sets the missing_records_message of this DomainDto.

        If the domain is missing records then show which pairs are missing.  # noqa: E501

        :param missing_records_message: The missing_records_message of this DomainDto.  # noqa: E501
        :type: str
        """

        self._missing_records_message = missing_records_message

    @property
    def has_missing_records(self):
        """Gets the has_missing_records of this DomainDto.  # noqa: E501

        Whether the domain has missing required records. If true then see the domain in the dashboard app.  # noqa: E501

        :return: The has_missing_records of this DomainDto.  # noqa: E501
        :rtype: bool
        """
        return self._has_missing_records

    @has_missing_records.setter
    def has_missing_records(self, has_missing_records):
        """Sets the has_missing_records of this DomainDto.

        Whether the domain has missing required records. If true then see the domain in the dashboard app.  # noqa: E501

        :param has_missing_records: The has_missing_records of this DomainDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and has_missing_records is None:  # noqa: E501
            raise ValueError("Invalid value for `has_missing_records`, must not be `None`")  # noqa: E501

        self._has_missing_records = has_missing_records

    @property
    def is_verified(self):
        """Gets the is_verified of this DomainDto.  # noqa: E501

        Whether domain has been verified or not. If the domain is not verified after 72 hours there is most likely an issue with the domains DNS records.  # noqa: E501

        :return: The is_verified of this DomainDto.  # noqa: E501
        :rtype: bool
        """
        return self._is_verified

    @is_verified.setter
    def is_verified(self, is_verified):
        """Sets the is_verified of this DomainDto.

        Whether domain has been verified or not. If the domain is not verified after 72 hours there is most likely an issue with the domains DNS records.  # noqa: E501

        :param is_verified: The is_verified of this DomainDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and is_verified is None:  # noqa: E501
            raise ValueError("Invalid value for `is_verified`, must not be `None`")  # noqa: E501

        self._is_verified = is_verified

    @property
    def domain_name_records(self):
        """Gets the domain_name_records of this DomainDto.  # noqa: E501

        List of DNS domain name records (C, MX, TXT) etc that you must add to the DNS server associated with your domain provider.  # noqa: E501

        :return: The domain_name_records of this DomainDto.  # noqa: E501
        :rtype: list[DomainNameRecord]
        """
        return self._domain_name_records

    @domain_name_records.setter
    def domain_name_records(self, domain_name_records):
        """Sets the domain_name_records of this DomainDto.

        List of DNS domain name records (C, MX, TXT) etc that you must add to the DNS server associated with your domain provider.  # noqa: E501

        :param domain_name_records: The domain_name_records of this DomainDto.  # noqa: E501
        :type: list[DomainNameRecord]
        """
        if self.local_vars_configuration.client_side_validation and domain_name_records is None:  # noqa: E501
            raise ValueError("Invalid value for `domain_name_records`, must not be `None`")  # noqa: E501

        self._domain_name_records = domain_name_records

    @property
    def catch_all_inbox_id(self):
        """Gets the catch_all_inbox_id of this DomainDto.  # noqa: E501

        The optional catch all inbox that will receive emails sent to the domain that cannot be matched.  # noqa: E501

        :return: The catch_all_inbox_id of this DomainDto.  # noqa: E501
        :rtype: str
        """
        return self._catch_all_inbox_id

    @catch_all_inbox_id.setter
    def catch_all_inbox_id(self, catch_all_inbox_id):
        """Sets the catch_all_inbox_id of this DomainDto.

        The optional catch all inbox that will receive emails sent to the domain that cannot be matched.  # noqa: E501

        :param catch_all_inbox_id: The catch_all_inbox_id of this DomainDto.  # noqa: E501
        :type: str
        """

        self._catch_all_inbox_id = catch_all_inbox_id

    @property
    def created_at(self):
        """Gets the created_at of this DomainDto.  # noqa: E501


        :return: The created_at of this DomainDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this DomainDto.


        :param created_at: The created_at of this DomainDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this DomainDto.  # noqa: E501


        :return: The updated_at of this DomainDto.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this DomainDto.


        :param updated_at: The updated_at of this DomainDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    @property
    def domain_type(self):
        """Gets the domain_type of this DomainDto.  # noqa: E501

        Type of domain. Dictates type of inbox that can be created with domain. HTTP means inboxes are processed using SES while SMTP inboxes use a custom SMTP mail server. SMTP does not support sending so use HTTP for sending emails.  # noqa: E501

        :return: The domain_type of this DomainDto.  # noqa: E501
        :rtype: str
        """
        return self._domain_type

    @domain_type.setter
    def domain_type(self, domain_type):
        """Sets the domain_type of this DomainDto.

        Type of domain. Dictates type of inbox that can be created with domain. HTTP means inboxes are processed using SES while SMTP inboxes use a custom SMTP mail server. SMTP does not support sending so use HTTP for sending emails.  # noqa: E501

        :param domain_type: The domain_type of this DomainDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and domain_type is None:  # noqa: E501
            raise ValueError("Invalid value for `domain_type`, must not be `None`")  # noqa: E501
        allowed_values = ["HTTP_INBOX", "SMTP_DOMAIN"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and domain_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `domain_type` ({0}), must be one of {1}"  # noqa: E501
                .format(domain_type, allowed_values)
            )

        self._domain_type = domain_type

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, DomainDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, DomainDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/dns_lookups_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class DNSLookupsOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'lookups': 'list[DNSLookupOptions]'
    }

    attribute_map = {
        'lookups': 'lookups'
    }

    def __init__(self, lookups=None, local_vars_configuration=None):  # noqa: E501
        """DNSLookupsOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._lookups = None
        self.discriminator = None

        self.lookups = lookups

    @property
    def lookups(self):
        """Gets the lookups of this DNSLookupsOptions.  # noqa: E501


        :return: The lookups of this DNSLookupsOptions.  # noqa: E501
        :rtype: list[DNSLookupOptions]
        """
        return self._lookups

    @lookups.setter
    def lookups(self, lookups):
        """Sets the lookups of this DNSLookupsOptions.


        :param lookups: The lookups of this DNSLookupsOptions.  # noqa: E501
        :type: list[DNSLookupOptions]
        """
        if self.local_vars_configuration.client_side_validation and lookups is None:  # noqa: E501
            raise ValueError("Invalid value for `lookups`, must not be `None`")  # noqa: E501

        self._lookups = lookups

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, DNSLookupsOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, DNSLookupsOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/dns_lookup_results.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class DNSLookupResults(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'results': 'list[DNSLookupResult]'
    }

    attribute_map = {
        'results': 'results'
    }

    def __init__(self, results=None, local_vars_configuration=None):  # noqa: E501
        """DNSLookupResults - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._results = None
        self.discriminator = None

        self.results = results

    @property
    def results(self):
        """Gets the results of this DNSLookupResults.  # noqa: E501


        :return: The results of this DNSLookupResults.  # noqa: E501
        :rtype: list[DNSLookupResult]
        """
        return self._results

    @results.setter
    def results(self, results):
        """Sets the results of this DNSLookupResults.


        :param results: The results of this DNSLookupResults.  # noqa: E501
        :type: list[DNSLookupResult]
        """
        if self.local_vars_configuration.client_side_validation and results is None:  # noqa: E501
            raise ValueError("Invalid value for `results`, must not be `None`")  # noqa: E501

        self._results = results

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, DNSLookupResults):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, DNSLookupResults):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/dns_lookup_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class DNSLookupResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'record_type': 'str',
        'ttl': 'int',
        'record_entries': 'list[str]',
        'name': 'str'
    }

    attribute_map = {
        'record_type': 'recordType',
        'ttl': 'ttl',
        'record_entries': 'recordEntries',
        'name': 'name'
    }

    def __init__(self, record_type=None, ttl=None, record_entries=None, name=None, local_vars_configuration=None):  # noqa: E501
        """DNSLookupResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._record_type = None
        self._ttl = None
        self._record_entries = None
        self._name = None
        self.discriminator = None

        self.record_type = record_type
        self.ttl = ttl
        self.record_entries = record_entries
        self.name = name

    @property
    def record_type(self):
        """Gets the record_type of this DNSLookupResult.  # noqa: E501

        Domain Name Server Record Types  # noqa: E501

        :return: The record_type of this DNSLookupResult.  # noqa: E501
        :rtype: str
        """
        return self._record_type

    @record_type.setter
    def record_type(self, record_type):
        """Sets the record_type of this DNSLookupResult.

        Domain Name Server Record Types  # noqa: E501

        :param record_type: The record_type of this DNSLookupResult.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and record_type is None:  # noqa: E501
            raise ValueError("Invalid value for `record_type`, must not be `None`")  # noqa: E501
        allowed_values = ["A", "NS", "MD", "MF", "CNAME", "SOA", "MB", "MG", "MR", "NULL", "WKS", "PTR", "HINFO", "MINFO", "MX", "TXT", "RP", "AFSDB", "X25", "ISDN", "RT", "NSAP", "NSAP_PTR", "SIG", "KEY", "PX", "GPOS", "AAAA", "LOC", "NXT", "EID", "NIMLOC", "SRV", "ATMA", "NAPTR", "KX", "CERT", "A6", "DNAME", "SINK", "OPT", "APL", "DS", "SSHFP", "IPSECKEY", "RRSIG", "NSEC", "DNSKEY", "DHCID", "NSEC3", "NSEC3PARAM", "TLSA", "SMIMEA", "HIP", "NINFO", "RKEY", "TALINK", "CDS", "CDNSKEY", "OPENPGPKEY", "CSYNC", "ZONEMD", "SVCB", "HTTPS", "SPF", "UINFO", "UID", "GID", "UNSPEC", "NID", "L32", "L64", "LP", "EUI48", "EUI64", "TKEY", "TSIG", "IXFR", "AXFR", "MAILB", "MAILA", "ANY", "URI", "CAA", "AVC", "DOA", "AMTRELAY", "TA", "DLV"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and record_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `record_type` ({0}), must be one of {1}"  # noqa: E501
                .format(record_type, allowed_values)
            )

        self._record_type = record_type

    @property
    def ttl(self):
        """Gets the ttl of this DNSLookupResult.  # noqa: E501


        :return: The ttl of this DNSLookupResult.  # noqa: E501
        :rtype: int
        """
        return self._ttl

    @ttl.setter
    def ttl(self, ttl):
        """Sets the ttl of this DNSLookupResult.


        :param ttl: The ttl of this DNSLookupResult.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and ttl is None:  # noqa: E501
            raise ValueError("Invalid value for `ttl`, must not be `None`")  # noqa: E501

        self._ttl = ttl

    @property
    def record_entries(self):
        """Gets the record_entries of this DNSLookupResult.  # noqa: E501


        :return: The record_entries of this DNSLookupResult.  # noqa: E501
        :rtype: list[str]
        """
        return self._record_entries

    @record_entries.setter
    def record_entries(self, record_entries):
        """Sets the record_entries of this DNSLookupResult.


        :param record_entries: The record_entries of this DNSLookupResult.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and record_entries is None:  # noqa: E501
            raise ValueError("Invalid value for `record_entries`, must not be `None`")  # noqa: E501

        self._record_entries = record_entries

    @property
    def name(self):
        """Gets the name of this DNSLookupResult.  # noqa: E501


        :return: The name of this DNSLookupResult.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this DNSLookupResult.


        :param name: The name of this DNSLookupResult.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, DNSLookupResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, DNSLookupResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/dns_lookup_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class DNSLookupOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'hostname': 'str',
        'record_types': 'list[str]',
        'omit_final_dns_dot': 'bool'
    }

    attribute_map = {
        'hostname': 'hostname',
        'record_types': 'recordTypes',
        'omit_final_dns_dot': 'omitFinalDNSDot'
    }

    def __init__(self, hostname=None, record_types=None, omit_final_dns_dot=None, local_vars_configuration=None):  # noqa: E501
        """DNSLookupOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._hostname = None
        self._record_types = None
        self._omit_final_dns_dot = None
        self.discriminator = None

        self.hostname = hostname
        self.record_types = record_types
        self.omit_final_dns_dot = omit_final_dns_dot

    @property
    def hostname(self):
        """Gets the hostname of this DNSLookupOptions.  # noqa: E501

        List of record types you wish to query such as MX, DNS, TXT, NS, A etc.  # noqa: E501

        :return: The hostname of this DNSLookupOptions.  # noqa: E501
        :rtype: str
        """
        return self._hostname

    @hostname.setter
    def hostname(self, hostname):
        """Sets the hostname of this DNSLookupOptions.

        List of record types you wish to query such as MX, DNS, TXT, NS, A etc.  # noqa: E501

        :param hostname: The hostname of this DNSLookupOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and hostname is None:  # noqa: E501
            raise ValueError("Invalid value for `hostname`, must not be `None`")  # noqa: E501

        self._hostname = hostname

    @property
    def record_types(self):
        """Gets the record_types of this DNSLookupOptions.  # noqa: E501

        List of record types you wish to query such as MX, DNS, TXT, NS, A etc.  # noqa: E501

        :return: The record_types of this DNSLookupOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._record_types

    @record_types.setter
    def record_types(self, record_types):
        """Sets the record_types of this DNSLookupOptions.

        List of record types you wish to query such as MX, DNS, TXT, NS, A etc.  # noqa: E501

        :param record_types: The record_types of this DNSLookupOptions.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and record_types is None:  # noqa: E501
            raise ValueError("Invalid value for `record_types`, must not be `None`")  # noqa: E501
        allowed_values = ["A", "NS", "MD", "MF", "CNAME", "SOA", "MB", "MG", "MR", "NULL", "WKS", "PTR", "HINFO", "MINFO", "MX", "TXT", "RP", "AFSDB", "X25", "ISDN", "RT", "NSAP", "NSAP_PTR", "SIG", "KEY", "PX", "GPOS", "AAAA", "LOC", "NXT", "EID", "NIMLOC", "SRV", "ATMA", "NAPTR", "KX", "CERT", "A6", "DNAME", "SINK", "OPT", "APL", "DS", "SSHFP", "IPSECKEY", "RRSIG", "NSEC", "DNSKEY", "DHCID", "NSEC3", "NSEC3PARAM", "TLSA", "SMIMEA", "HIP", "NINFO", "RKEY", "TALINK", "CDS", "CDNSKEY", "OPENPGPKEY", "CSYNC", "ZONEMD", "SVCB", "HTTPS", "SPF", "UINFO", "UID", "GID", "UNSPEC", "NID", "L32", "L64", "LP", "EUI48", "EUI64", "TKEY", "TSIG", "IXFR", "AXFR", "MAILB", "MAILA", "ANY", "URI", "CAA", "AVC", "DOA", "AMTRELAY", "TA", "DLV"]  # noqa: E501
        if (self.local_vars_configuration.client_side_validation and
                not set(record_types).issubset(set(allowed_values))):  # noqa: E501
            raise ValueError(
                "Invalid values for `record_types` [{0}], must be a subset of [{1}]"  # noqa: E501
                .format(", ".join(map(str, set(record_types) - set(allowed_values))),  # noqa: E501
                        ", ".join(map(str, allowed_values)))
            )

        self._record_types = record_types

    @property
    def omit_final_dns_dot(self):
        """Gets the omit_final_dns_dot of this DNSLookupOptions.  # noqa: E501

        Optionally control whether to omit the final dot in full DNS name values.  # noqa: E501

        :return: The omit_final_dns_dot of this DNSLookupOptions.  # noqa: E501
        :rtype: bool
        """
        return self._omit_final_dns_dot

    @omit_final_dns_dot.setter
    def omit_final_dns_dot(self, omit_final_dns_dot):
        """Sets the omit_final_dns_dot of this DNSLookupOptions.

        Optionally control whether to omit the final dot in full DNS name values.  # noqa: E501

        :param omit_final_dns_dot: The omit_final_dns_dot of this DNSLookupOptions.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and omit_final_dns_dot is None:  # noqa: E501
            raise ValueError("Invalid value for `omit_final_dns_dot`, must not be `None`")  # noqa: E501

        self._omit_final_dns_dot = omit_final_dns_dot

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, DNSLookupOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, DNSLookupOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/describe_mail_server_domain_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class DescribeMailServerDomainResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'mx_records': 'list[NameServerRecord]',
        'domain': 'str',
        'message': 'str'
    }

    attribute_map = {
        'mx_records': 'mxRecords',
        'domain': 'domain',
        'message': 'message'
    }

    def __init__(self, mx_records=None, domain=None, message=None, local_vars_configuration=None):  # noqa: E501
        """DescribeMailServerDomainResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._mx_records = None
        self._domain = None
        self._message = None
        self.discriminator = None

        self.mx_records = mx_records
        self.domain = domain
        self.message = message

    @property
    def mx_records(self):
        """Gets the mx_records of this DescribeMailServerDomainResult.  # noqa: E501


        :return: The mx_records of this DescribeMailServerDomainResult.  # noqa: E501
        :rtype: list[NameServerRecord]
        """
        return self._mx_records

    @mx_records.setter
    def mx_records(self, mx_records):
        """Sets the mx_records of this DescribeMailServerDomainResult.


        :param mx_records: The mx_records of this DescribeMailServerDomainResult.  # noqa: E501
        :type: list[NameServerRecord]
        """
        if self.local_vars_configuration.client_side_validation and mx_records is None:  # noqa: E501
            raise ValueError("Invalid value for `mx_records`, must not be `None`")  # noqa: E501

        self._mx_records = mx_records

    @property
    def domain(self):
        """Gets the domain of this DescribeMailServerDomainResult.  # noqa: E501


        :return: The domain of this DescribeMailServerDomainResult.  # noqa: E501
        :rtype: str
        """
        return self._domain

    @domain.setter
    def domain(self, domain):
        """Sets the domain of this DescribeMailServerDomainResult.


        :param domain: The domain of this DescribeMailServerDomainResult.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and domain is None:  # noqa: E501
            raise ValueError("Invalid value for `domain`, must not be `None`")  # noqa: E501

        self._domain = domain

    @property
    def message(self):
        """Gets the message of this DescribeMailServerDomainResult.  # noqa: E501


        :return: The message of this DescribeMailServerDomainResult.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this DescribeMailServerDomainResult.


        :param message: The message of this DescribeMailServerDomainResult.  # noqa: E501
        :type: str
        """

        self._message = message

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, DescribeMailServerDomainResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, DescribeMailServerDomainResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/describe_domain_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class DescribeDomainOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'domain': 'str'
    }

    attribute_map = {
        'domain': 'domain'
    }

    def __init__(self, domain=None, local_vars_configuration=None):  # noqa: E501
        """DescribeDomainOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._domain = None
        self.discriminator = None

        self.domain = domain

    @property
    def domain(self):
        """Gets the domain of this DescribeDomainOptions.  # noqa: E501


        :return: The domain of this DescribeDomainOptions.  # noqa: E501
        :rtype: str
        """
        return self._domain

    @domain.setter
    def domain(self, domain):
        """Sets the domain of this DescribeDomainOptions.


        :param domain: The domain of this DescribeDomainOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and domain is None:  # noqa: E501
            raise ValueError("Invalid value for `domain`, must not be `None`")  # noqa: E501

        self._domain = domain

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, DescribeDomainOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, DescribeDomainOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/delivery_status_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class DeliveryStatusDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'sent_id': 'str',
        'remote_mta_ip': 'str',
        'inbox_id': 'str',
        'reporting_mta': 'str',
        'recipients': 'list[str]',
        'smtp_response': 'str',
        'smtp_status_code': 'int',
        'processing_time_millis': 'int',
        'received': 'datetime',
        'subject': 'str',
        'created_at': 'datetime',
        'updated_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'sent_id': 'sentId',
        'remote_mta_ip': 'remoteMtaIp',
        'inbox_id': 'inboxId',
        'reporting_mta': 'reportingMta',
        'recipients': 'recipients',
        'smtp_response': 'smtpResponse',
        'smtp_status_code': 'smtpStatusCode',
        'processing_time_millis': 'processingTimeMillis',
        'received': 'received',
        'subject': 'subject',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt'
    }

    def __init__(self, id=None, user_id=None, sent_id=None, remote_mta_ip=None, inbox_id=None, reporting_mta=None, recipients=None, smtp_response=None, smtp_status_code=None, processing_time_millis=None, received=None, subject=None, created_at=None, updated_at=None, local_vars_configuration=None):  # noqa: E501
        """DeliveryStatusDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._sent_id = None
        self._remote_mta_ip = None
        self._inbox_id = None
        self._reporting_mta = None
        self._recipients = None
        self._smtp_response = None
        self._smtp_status_code = None
        self._processing_time_millis = None
        self._received = None
        self._subject = None
        self._created_at = None
        self._updated_at = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        if sent_id is not None:
            self.sent_id = sent_id
        if remote_mta_ip is not None:
            self.remote_mta_ip = remote_mta_ip
        if inbox_id is not None:
            self.inbox_id = inbox_id
        if reporting_mta is not None:
            self.reporting_mta = reporting_mta
        if recipients is not None:
            self.recipients = recipients
        if smtp_response is not None:
            self.smtp_response = smtp_response
        if smtp_status_code is not None:
            self.smtp_status_code = smtp_status_code
        if processing_time_millis is not None:
            self.processing_time_millis = processing_time_millis
        if received is not None:
            self.received = received
        if subject is not None:
            self.subject = subject
        self.created_at = created_at
        self.updated_at = updated_at

    @property
    def id(self):
        """Gets the id of this DeliveryStatusDto.  # noqa: E501


        :return: The id of this DeliveryStatusDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this DeliveryStatusDto.


        :param id: The id of this DeliveryStatusDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this DeliveryStatusDto.  # noqa: E501


        :return: The user_id of this DeliveryStatusDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this DeliveryStatusDto.


        :param user_id: The user_id of this DeliveryStatusDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def sent_id(self):
        """Gets the sent_id of this DeliveryStatusDto.  # noqa: E501


        :return: The sent_id of this DeliveryStatusDto.  # noqa: E501
        :rtype: str
        """
        return self._sent_id

    @sent_id.setter
    def sent_id(self, sent_id):
        """Sets the sent_id of this DeliveryStatusDto.


        :param sent_id: The sent_id of this DeliveryStatusDto.  # noqa: E501
        :type: str
        """

        self._sent_id = sent_id

    @property
    def remote_mta_ip(self):
        """Gets the remote_mta_ip of this DeliveryStatusDto.  # noqa: E501


        :return: The remote_mta_ip of this DeliveryStatusDto.  # noqa: E501
        :rtype: str
        """
        return self._remote_mta_ip

    @remote_mta_ip.setter
    def remote_mta_ip(self, remote_mta_ip):
        """Sets the remote_mta_ip of this DeliveryStatusDto.


        :param remote_mta_ip: The remote_mta_ip of this DeliveryStatusDto.  # noqa: E501
        :type: str
        """

        self._remote_mta_ip = remote_mta_ip

    @property
    def inbox_id(self):
        """Gets the inbox_id of this DeliveryStatusDto.  # noqa: E501


        :return: The inbox_id of this DeliveryStatusDto.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this DeliveryStatusDto.


        :param inbox_id: The inbox_id of this DeliveryStatusDto.  # noqa: E501
        :type: str
        """

        self._inbox_id = inbox_id

    @property
    def reporting_mta(self):
        """Gets the reporting_mta of this DeliveryStatusDto.  # noqa: E501


        :return: The reporting_mta of this DeliveryStatusDto.  # noqa: E501
        :rtype: str
        """
        return self._reporting_mta

    @reporting_mta.setter
    def reporting_mta(self, reporting_mta):
        """Sets the reporting_mta of this DeliveryStatusDto.


        :param reporting_mta: The reporting_mta of this DeliveryStatusDto.  # noqa: E501
        :type: str
        """

        self._reporting_mta = reporting_mta

    @property
    def recipients(self):
        """Gets the recipients of this DeliveryStatusDto.  # noqa: E501


        :return: The recipients of this DeliveryStatusDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._recipients

    @recipients.setter
    def recipients(self, recipients):
        """Sets the recipients of this DeliveryStatusDto.


        :param recipients: The recipients of this DeliveryStatusDto.  # noqa: E501
        :type: list[str]
        """

        self._recipients = recipients

    @property
    def smtp_response(self):
        """Gets the smtp_response of this DeliveryStatusDto.  # noqa: E501


        :return: The smtp_response of this DeliveryStatusDto.  # noqa: E501
        :rtype: str
        """
        return self._smtp_response

    @smtp_response.setter
    def smtp_response(self, smtp_response):
        """Sets the smtp_response of this DeliveryStatusDto.


        :param smtp_response: The smtp_response of this DeliveryStatusDto.  # noqa: E501
        :type: str
        """

        self._smtp_response = smtp_response

    @property
    def smtp_status_code(self):
        """Gets the smtp_status_code of this DeliveryStatusDto.  # noqa: E501


        :return: The smtp_status_code of this DeliveryStatusDto.  # noqa: E501
        :rtype: int
        """
        return self._smtp_status_code

    @smtp_status_code.setter
    def smtp_status_code(self, smtp_status_code):
        """Sets the smtp_status_code of this DeliveryStatusDto.


        :param smtp_status_code: The smtp_status_code of this DeliveryStatusDto.  # noqa: E501
        :type: int
        """

        self._smtp_status_code = smtp_status_code

    @property
    def processing_time_millis(self):
        """Gets the processing_time_millis of this DeliveryStatusDto.  # noqa: E501


        :return: The processing_time_millis of this DeliveryStatusDto.  # noqa: E501
        :rtype: int
        """
        return self._processing_time_millis

    @processing_time_millis.setter
    def processing_time_millis(self, processing_time_millis):
        """Sets the processing_time_millis of this DeliveryStatusDto.


        :param processing_time_millis: The processing_time_millis of this DeliveryStatusDto.  # noqa: E501
        :type: int
        """

        self._processing_time_millis = processing_time_millis

    @property
    def received(self):
        """Gets the received of this DeliveryStatusDto.  # noqa: E501


        :return: The received of this DeliveryStatusDto.  # noqa: E501
        :rtype: datetime
        """
        return self._received

    @received.setter
    def received(self, received):
        """Sets the received of this DeliveryStatusDto.


        :param received: The received of this DeliveryStatusDto.  # noqa: E501
        :type: datetime
        """

        self._received = received

    @property
    def subject(self):
        """Gets the subject of this DeliveryStatusDto.  # noqa: E501


        :return: The subject of this DeliveryStatusDto.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this DeliveryStatusDto.


        :param subject: The subject of this DeliveryStatusDto.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def created_at(self):
        """Gets the created_at of this DeliveryStatusDto.  # noqa: E501


        :return: The created_at of this DeliveryStatusDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this DeliveryStatusDto.


        :param created_at: The created_at of this DeliveryStatusDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this DeliveryStatusDto.  # noqa: E501


        :return: The updated_at of this DeliveryStatusDto.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this DeliveryStatusDto.


        :param updated_at: The updated_at of this DeliveryStatusDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, DeliveryStatusDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, DeliveryStatusDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/create_webhook_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CreateWebhookOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'url': 'str',
        'basic_auth': 'BasicAuthOptions',
        'name': 'str',
        'event_name': 'str',
        'include_headers': 'WebhookHeaders',
        'request_body_template': 'str',
        'use_static_ip_range': 'bool',
        'ignore_insecure_ssl_certificates': 'bool'
    }

    attribute_map = {
        'url': 'url',
        'basic_auth': 'basicAuth',
        'name': 'name',
        'event_name': 'eventName',
        'include_headers': 'includeHeaders',
        'request_body_template': 'requestBodyTemplate',
        'use_static_ip_range': 'useStaticIpRange',
        'ignore_insecure_ssl_certificates': 'ignoreInsecureSslCertificates'
    }

    def __init__(self, url=None, basic_auth=None, name=None, event_name=None, include_headers=None, request_body_template=None, use_static_ip_range=False, ignore_insecure_ssl_certificates=None, local_vars_configuration=None):  # noqa: E501
        """CreateWebhookOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._url = None
        self._basic_auth = None
        self._name = None
        self._event_name = None
        self._include_headers = None
        self._request_body_template = None
        self._use_static_ip_range = None
        self._ignore_insecure_ssl_certificates = None
        self.discriminator = None

        self.url = url
        self.basic_auth = basic_auth
        self.name = name
        self.event_name = event_name
        if include_headers is not None:
            self.include_headers = include_headers
        self.request_body_template = request_body_template
        self.use_static_ip_range = use_static_ip_range
        self.ignore_insecure_ssl_certificates = ignore_insecure_ssl_certificates

    @property
    def url(self):
        """Gets the url of this CreateWebhookOptions.  # noqa: E501

        Public URL on your server that MailSlurp can post WebhookNotification payload to when an email is received or an event is trigger. The payload of the submitted JSON is dependent on the webhook event type. See docs.mailslurp.com/webhooks for event payload documentation.  # noqa: E501

        :return: The url of this CreateWebhookOptions.  # noqa: E501
        :rtype: str
        """
        return self._url

    @url.setter
    def url(self, url):
        """Sets the url of this CreateWebhookOptions.

        Public URL on your server that MailSlurp can post WebhookNotification payload to when an email is received or an event is trigger. The payload of the submitted JSON is dependent on the webhook event type. See docs.mailslurp.com/webhooks for event payload documentation.  # noqa: E501

        :param url: The url of this CreateWebhookOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and url is None:  # noqa: E501
            raise ValueError("Invalid value for `url`, must not be `None`")  # noqa: E501

        self._url = url

    @property
    def basic_auth(self):
        """Gets the basic_auth of this CreateWebhookOptions.  # noqa: E501


        :return: The basic_auth of this CreateWebhookOptions.  # noqa: E501
        :rtype: BasicAuthOptions
        """
        return self._basic_auth

    @basic_auth.setter
    def basic_auth(self, basic_auth):
        """Sets the basic_auth of this CreateWebhookOptions.


        :param basic_auth: The basic_auth of this CreateWebhookOptions.  # noqa: E501
        :type: BasicAuthOptions
        """

        self._basic_auth = basic_auth

    @property
    def name(self):
        """Gets the name of this CreateWebhookOptions.  # noqa: E501

        Optional name for the webhook  # noqa: E501

        :return: The name of this CreateWebhookOptions.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this CreateWebhookOptions.

        Optional name for the webhook  # noqa: E501

        :param name: The name of this CreateWebhookOptions.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def event_name(self):
        """Gets the event_name of this CreateWebhookOptions.  # noqa: E501

        Optional webhook event name. Default is `EMAIL_RECEIVED` and is triggered when an email is received by the inbox associated with the webhook. Payload differ according to the webhook event name.  # noqa: E501

        :return: The event_name of this CreateWebhookOptions.  # noqa: E501
        :rtype: str
        """
        return self._event_name

    @event_name.setter
    def event_name(self, event_name):
        """Sets the event_name of this CreateWebhookOptions.

        Optional webhook event name. Default is `EMAIL_RECEIVED` and is triggered when an email is received by the inbox associated with the webhook. Payload differ according to the webhook event name.  # noqa: E501

        :param event_name: The event_name of this CreateWebhookOptions.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"EMAIL_RECEIVED", "NEW_EMAIL", "NEW_CONTACT", "NEW_ATTACHMENT", "EMAIL_OPENED", "EMAIL_READ", "DELIVERY_STATUS", "BOUNCE", "BOUNCE_RECIPIENT", "NEW_SMS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and event_name not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `event_name` ({0}), must be one of {1}"  # noqa: E501
                .format(event_name, allowed_values)
            )

        self._event_name = event_name

    @property
    def include_headers(self):
        """Gets the include_headers of this CreateWebhookOptions.  # noqa: E501


        :return: The include_headers of this CreateWebhookOptions.  # noqa: E501
        :rtype: WebhookHeaders
        """
        return self._include_headers

    @include_headers.setter
    def include_headers(self, include_headers):
        """Sets the include_headers of this CreateWebhookOptions.


        :param include_headers: The include_headers of this CreateWebhookOptions.  # noqa: E501
        :type: WebhookHeaders
        """

        self._include_headers = include_headers

    @property
    def request_body_template(self):
        """Gets the request_body_template of this CreateWebhookOptions.  # noqa: E501

        Template for the JSON body of the webhook request that will be sent to your server. Use Moustache style `{{variableName}}` templating to use parts of the standard webhook payload for the given event.  # noqa: E501

        :return: The request_body_template of this CreateWebhookOptions.  # noqa: E501
        :rtype: str
        """
        return self._request_body_template

    @request_body_template.setter
    def request_body_template(self, request_body_template):
        """Sets the request_body_template of this CreateWebhookOptions.

        Template for the JSON body of the webhook request that will be sent to your server. Use Moustache style `{{variableName}}` templating to use parts of the standard webhook payload for the given event.  # noqa: E501

        :param request_body_template: The request_body_template of this CreateWebhookOptions.  # noqa: E501
        :type: str
        """

        self._request_body_template = request_body_template

    @property
    def use_static_ip_range(self):
        """Gets the use_static_ip_range of this CreateWebhookOptions.  # noqa: E501

        Use static IP range when calling webhook endpoint  # noqa: E501

        :return: The use_static_ip_range of this CreateWebhookOptions.  # noqa: E501
        :rtype: bool
        """
        return self._use_static_ip_range

    @use_static_ip_range.setter
    def use_static_ip_range(self, use_static_ip_range):
        """Sets the use_static_ip_range of this CreateWebhookOptions.

        Use static IP range when calling webhook endpoint  # noqa: E501

        :param use_static_ip_range: The use_static_ip_range of this CreateWebhookOptions.  # noqa: E501
        :type: bool
        """

        self._use_static_ip_range = use_static_ip_range

    @property
    def ignore_insecure_ssl_certificates(self):
        """Gets the ignore_insecure_ssl_certificates of this CreateWebhookOptions.  # noqa: E501

        Ignore insecure SSL certificates when sending request. Useful for self-signed certs.  # noqa: E501

        :return: The ignore_insecure_ssl_certificates of this CreateWebhookOptions.  # noqa: E501
        :rtype: bool
        """
        return self._ignore_insecure_ssl_certificates

    @ignore_insecure_ssl_certificates.setter
    def ignore_insecure_ssl_certificates(self, ignore_insecure_ssl_certificates):
        """Sets the ignore_insecure_ssl_certificates of this CreateWebhookOptions.

        Ignore insecure SSL certificates when sending request. Useful for self-signed certs.  # noqa: E501

        :param ignore_insecure_ssl_certificates: The ignore_insecure_ssl_certificates of this CreateWebhookOptions.  # noqa: E501
        :type: bool
        """

        self._ignore_insecure_ssl_certificates = ignore_insecure_ssl_certificates

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CreateWebhookOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CreateWebhookOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/create_tracking_pixel_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CreateTrackingPixelOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'name': 'str',
        'recipient': 'str'
    }

    attribute_map = {
        'name': 'name',
        'recipient': 'recipient'
    }

    def __init__(self, name=None, recipient=None, local_vars_configuration=None):  # noqa: E501
        """CreateTrackingPixelOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._name = None
        self._recipient = None
        self.discriminator = None

        self.name = name
        self.recipient = recipient

    @property
    def name(self):
        """Gets the name of this CreateTrackingPixelOptions.  # noqa: E501


        :return: The name of this CreateTrackingPixelOptions.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this CreateTrackingPixelOptions.


        :param name: The name of this CreateTrackingPixelOptions.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def recipient(self):
        """Gets the recipient of this CreateTrackingPixelOptions.  # noqa: E501


        :return: The recipient of this CreateTrackingPixelOptions.  # noqa: E501
        :rtype: str
        """
        return self._recipient

    @recipient.setter
    def recipient(self, recipient):
        """Sets the recipient of this CreateTrackingPixelOptions.


        :param recipient: The recipient of this CreateTrackingPixelOptions.  # noqa: E501
        :type: str
        """

        self._recipient = recipient

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CreateTrackingPixelOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CreateTrackingPixelOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/create_template_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CreateTemplateOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'name': 'str',
        'content': 'str'
    }

    attribute_map = {
        'name': 'name',
        'content': 'content'
    }

    def __init__(self, name=None, content=None, local_vars_configuration=None):  # noqa: E501
        """CreateTemplateOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._name = None
        self._content = None
        self.discriminator = None

        self.name = name
        self.content = content

    @property
    def name(self):
        """Gets the name of this CreateTemplateOptions.  # noqa: E501

        Name of template  # noqa: E501

        :return: The name of this CreateTemplateOptions.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this CreateTemplateOptions.

        Name of template  # noqa: E501

        :param name: The name of this CreateTemplateOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    @property
    def content(self):
        """Gets the content of this CreateTemplateOptions.  # noqa: E501

        Template content. Can include moustache style variables such as {{var_name}}  # noqa: E501

        :return: The content of this CreateTemplateOptions.  # noqa: E501
        :rtype: str
        """
        return self._content

    @content.setter
    def content(self, content):
        """Sets the content of this CreateTemplateOptions.

        Template content. Can include moustache style variables such as {{var_name}}  # noqa: E501

        :param content: The content of this CreateTemplateOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and content is None:  # noqa: E501
            raise ValueError("Invalid value for `content`, must not be `None`")  # noqa: E501

        self._content = content

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CreateTemplateOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CreateTemplateOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/create_inbox_ruleset_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CreateInboxRulesetOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'scope': 'str',
        'action': 'str',
        'target': 'str'
    }

    attribute_map = {
        'scope': 'scope',
        'action': 'action',
        'target': 'target'
    }

    def __init__(self, scope=None, action=None, target=None, local_vars_configuration=None):  # noqa: E501
        """CreateInboxRulesetOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._scope = None
        self._action = None
        self._target = None
        self.discriminator = None

        self.scope = scope
        self.action = action
        self.target = target

    @property
    def scope(self):
        """Gets the scope of this CreateInboxRulesetOptions.  # noqa: E501

        What type of emails actions to apply ruleset to. Either `SENDING_EMAILS` or `RECEIVING_EMAILS` will apply action and target to any sending or receiving of emails respectively.  # noqa: E501

        :return: The scope of this CreateInboxRulesetOptions.  # noqa: E501
        :rtype: str
        """
        return self._scope

    @scope.setter
    def scope(self, scope):
        """Sets the scope of this CreateInboxRulesetOptions.

        What type of emails actions to apply ruleset to. Either `SENDING_EMAILS` or `RECEIVING_EMAILS` will apply action and target to any sending or receiving of emails respectively.  # noqa: E501

        :param scope: The scope of this CreateInboxRulesetOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and scope is None:  # noqa: E501
            raise ValueError("Invalid value for `scope`, must not be `None`")  # noqa: E501
        allowed_values = ["RECEIVING_EMAILS", "SENDING_EMAILS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and scope not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `scope` ({0}), must be one of {1}"  # noqa: E501
                .format(scope, allowed_values)
            )

        self._scope = scope

    @property
    def action(self):
        """Gets the action of this CreateInboxRulesetOptions.  # noqa: E501

        Action to be taken when the ruleset matches an email for the given scope. For example: `BLOCK` action with target `*` and scope `SENDING_EMAILS` blocks sending to all recipients. Note `ALLOW` takes precedent over `BLOCK`. `FILTER_REMOVE` is like block but will remove offending email addresses during a send or receive event instead of blocking the action.  # noqa: E501

        :return: The action of this CreateInboxRulesetOptions.  # noqa: E501
        :rtype: str
        """
        return self._action

    @action.setter
    def action(self, action):
        """Sets the action of this CreateInboxRulesetOptions.

        Action to be taken when the ruleset matches an email for the given scope. For example: `BLOCK` action with target `*` and scope `SENDING_EMAILS` blocks sending to all recipients. Note `ALLOW` takes precedent over `BLOCK`. `FILTER_REMOVE` is like block but will remove offending email addresses during a send or receive event instead of blocking the action.  # noqa: E501

        :param action: The action of this CreateInboxRulesetOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and action is None:  # noqa: E501
            raise ValueError("Invalid value for `action`, must not be `None`")  # noqa: E501
        allowed_values = ["BLOCK", "ALLOW", "FILTER_REMOVE"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and action not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `action` ({0}), must be one of {1}"  # noqa: E501
                .format(action, allowed_values)
            )

        self._action = action

    @property
    def target(self):
        """Gets the target of this CreateInboxRulesetOptions.  # noqa: E501

        Target to match emails with. Can be a wild-card type pattern or a valid email address. For instance `*@gmail.com` matches all gmail addresses while `test@gmail.com` matches one address exactly. The target is applied to every recipient field email address when `SENDING_EMAILS` is the scope and is applied to sender of email when `RECEIVING_EMAILS`.  # noqa: E501

        :return: The target of this CreateInboxRulesetOptions.  # noqa: E501
        :rtype: str
        """
        return self._target

    @target.setter
    def target(self, target):
        """Sets the target of this CreateInboxRulesetOptions.

        Target to match emails with. Can be a wild-card type pattern or a valid email address. For instance `*@gmail.com` matches all gmail addresses while `test@gmail.com` matches one address exactly. The target is applied to every recipient field email address when `SENDING_EMAILS` is the scope and is applied to sender of email when `RECEIVING_EMAILS`.  # noqa: E501

        :param target: The target of this CreateInboxRulesetOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and target is None:  # noqa: E501
            raise ValueError("Invalid value for `target`, must not be `None`")  # noqa: E501

        self._target = target

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CreateInboxRulesetOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CreateInboxRulesetOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/create_inbox_replier_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CreateInboxReplierOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'inbox_id': 'str',
        'name': 'str',
        'field': 'str',
        'match': 'str',
        'reply_to': 'str',
        'subject': 'str',
        '_from': 'str',
        'charset': 'str',
        'ignore_reply_to': 'bool',
        'is_html': 'bool',
        'body': 'str',
        'template_id': 'str',
        'template_variables': 'dict(str, object)'
    }

    attribute_map = {
        'inbox_id': 'inboxId',
        'name': 'name',
        'field': 'field',
        'match': 'match',
        'reply_to': 'replyTo',
        'subject': 'subject',
        '_from': 'from',
        'charset': 'charset',
        'ignore_reply_to': 'ignoreReplyTo',
        'is_html': 'isHTML',
        'body': 'body',
        'template_id': 'templateId',
        'template_variables': 'templateVariables'
    }

    def __init__(self, inbox_id=None, name=None, field=None, match=None, reply_to=None, subject=None, _from=None, charset=None, ignore_reply_to=None, is_html=None, body=None, template_id=None, template_variables=None, local_vars_configuration=None):  # noqa: E501
        """CreateInboxReplierOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._inbox_id = None
        self._name = None
        self._field = None
        self._match = None
        self._reply_to = None
        self._subject = None
        self.__from = None
        self._charset = None
        self._ignore_reply_to = None
        self._is_html = None
        self._body = None
        self._template_id = None
        self._template_variables = None
        self.discriminator = None

        self.inbox_id = inbox_id
        self.name = name
        self.field = field
        self.match = match
        self.reply_to = reply_to
        self.subject = subject
        self._from = _from
        self.charset = charset
        self.ignore_reply_to = ignore_reply_to
        self.is_html = is_html
        self.body = body
        self.template_id = template_id
        self.template_variables = template_variables

    @property
    def inbox_id(self):
        """Gets the inbox_id of this CreateInboxReplierOptions.  # noqa: E501

        Inbox ID to attach replier to  # noqa: E501

        :return: The inbox_id of this CreateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this CreateInboxReplierOptions.

        Inbox ID to attach replier to  # noqa: E501

        :param inbox_id: The inbox_id of this CreateInboxReplierOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def name(self):
        """Gets the name of this CreateInboxReplierOptions.  # noqa: E501

        Name for replier  # noqa: E501

        :return: The name of this CreateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this CreateInboxReplierOptions.

        Name for replier  # noqa: E501

        :param name: The name of this CreateInboxReplierOptions.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def field(self):
        """Gets the field of this CreateInboxReplierOptions.  # noqa: E501

        Field to match against to trigger inbox replier for inbound email  # noqa: E501

        :return: The field of this CreateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._field

    @field.setter
    def field(self, field):
        """Sets the field of this CreateInboxReplierOptions.

        Field to match against to trigger inbox replier for inbound email  # noqa: E501

        :param field: The field of this CreateInboxReplierOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and field is None:  # noqa: E501
            raise ValueError("Invalid value for `field`, must not be `None`")  # noqa: E501
        allowed_values = ["RECIPIENTS", "SENDER", "SUBJECT", "ATTACHMENTS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and field not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `field` ({0}), must be one of {1}"  # noqa: E501
                .format(field, allowed_values)
            )

        self._field = field

    @property
    def match(self):
        """Gets the match of this CreateInboxReplierOptions.  # noqa: E501

        String or wildcard style match for field specified when evaluating reply rules. Use `*` to match anything.  # noqa: E501

        :return: The match of this CreateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._match

    @match.setter
    def match(self, match):
        """Sets the match of this CreateInboxReplierOptions.

        String or wildcard style match for field specified when evaluating reply rules. Use `*` to match anything.  # noqa: E501

        :param match: The match of this CreateInboxReplierOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and match is None:  # noqa: E501
            raise ValueError("Invalid value for `match`, must not be `None`")  # noqa: E501

        self._match = match

    @property
    def reply_to(self):
        """Gets the reply_to of this CreateInboxReplierOptions.  # noqa: E501

        Reply-to email address when sending replying  # noqa: E501

        :return: The reply_to of this CreateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._reply_to

    @reply_to.setter
    def reply_to(self, reply_to):
        """Sets the reply_to of this CreateInboxReplierOptions.

        Reply-to email address when sending replying  # noqa: E501

        :param reply_to: The reply_to of this CreateInboxReplierOptions.  # noqa: E501
        :type: str
        """

        self._reply_to = reply_to

    @property
    def subject(self):
        """Gets the subject of this CreateInboxReplierOptions.  # noqa: E501

        Subject override when replying to email  # noqa: E501

        :return: The subject of this CreateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this CreateInboxReplierOptions.

        Subject override when replying to email  # noqa: E501

        :param subject: The subject of this CreateInboxReplierOptions.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def _from(self):
        """Gets the _from of this CreateInboxReplierOptions.  # noqa: E501

        Send email from address  # noqa: E501

        :return: The _from of this CreateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self.__from

    @_from.setter
    def _from(self, _from):
        """Sets the _from of this CreateInboxReplierOptions.

        Send email from address  # noqa: E501

        :param _from: The _from of this CreateInboxReplierOptions.  # noqa: E501
        :type: str
        """

        self.__from = _from

    @property
    def charset(self):
        """Gets the charset of this CreateInboxReplierOptions.  # noqa: E501

        Email reply charset  # noqa: E501

        :return: The charset of this CreateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._charset

    @charset.setter
    def charset(self, charset):
        """Sets the charset of this CreateInboxReplierOptions.

        Email reply charset  # noqa: E501

        :param charset: The charset of this CreateInboxReplierOptions.  # noqa: E501
        :type: str
        """

        self._charset = charset

    @property
    def ignore_reply_to(self):
        """Gets the ignore_reply_to of this CreateInboxReplierOptions.  # noqa: E501

        Ignore sender replyTo when responding. Send directly to the sender if enabled.  # noqa: E501

        :return: The ignore_reply_to of this CreateInboxReplierOptions.  # noqa: E501
        :rtype: bool
        """
        return self._ignore_reply_to

    @ignore_reply_to.setter
    def ignore_reply_to(self, ignore_reply_to):
        """Sets the ignore_reply_to of this CreateInboxReplierOptions.

        Ignore sender replyTo when responding. Send directly to the sender if enabled.  # noqa: E501

        :param ignore_reply_to: The ignore_reply_to of this CreateInboxReplierOptions.  # noqa: E501
        :type: bool
        """

        self._ignore_reply_to = ignore_reply_to

    @property
    def is_html(self):
        """Gets the is_html of this CreateInboxReplierOptions.  # noqa: E501

        Send HTML email  # noqa: E501

        :return: The is_html of this CreateInboxReplierOptions.  # noqa: E501
        :rtype: bool
        """
        return self._is_html

    @is_html.setter
    def is_html(self, is_html):
        """Sets the is_html of this CreateInboxReplierOptions.

        Send HTML email  # noqa: E501

        :param is_html: The is_html of this CreateInboxReplierOptions.  # noqa: E501
        :type: bool
        """

        self._is_html = is_html

    @property
    def body(self):
        """Gets the body of this CreateInboxReplierOptions.  # noqa: E501

        Email body for reply  # noqa: E501

        :return: The body of this CreateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._body

    @body.setter
    def body(self, body):
        """Sets the body of this CreateInboxReplierOptions.

        Email body for reply  # noqa: E501

        :param body: The body of this CreateInboxReplierOptions.  # noqa: E501
        :type: str
        """

        self._body = body

    @property
    def template_id(self):
        """Gets the template_id of this CreateInboxReplierOptions.  # noqa: E501

        ID of template to use when sending a reply  # noqa: E501

        :return: The template_id of this CreateInboxReplierOptions.  # noqa: E501
        :rtype: str
        """
        return self._template_id

    @template_id.setter
    def template_id(self, template_id):
        """Sets the template_id of this CreateInboxReplierOptions.

        ID of template to use when sending a reply  # noqa: E501

        :param template_id: The template_id of this CreateInboxReplierOptions.  # noqa: E501
        :type: str
        """

        self._template_id = template_id

    @property
    def template_variables(self):
        """Gets the template_variables of this CreateInboxReplierOptions.  # noqa: E501

        Template variable values  # noqa: E501

        :return: The template_variables of this CreateInboxReplierOptions.  # noqa: E501
        :rtype: dict(str, object)
        """
        return self._template_variables

    @template_variables.setter
    def template_variables(self, template_variables):
        """Sets the template_variables of this CreateInboxReplierOptions.

        Template variable values  # noqa: E501

        :param template_variables: The template_variables of this CreateInboxReplierOptions.  # noqa: E501
        :type: dict(str, object)
        """

        self._template_variables = template_variables

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CreateInboxReplierOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CreateInboxReplierOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/create_inbox_forwarder_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CreateInboxForwarderOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'field': 'str',
        'match': 'str',
        'forward_to_recipients': 'list[str]'
    }

    attribute_map = {
        'field': 'field',
        'match': 'match',
        'forward_to_recipients': 'forwardToRecipients'
    }

    def __init__(self, field=None, match=None, forward_to_recipients=None, local_vars_configuration=None):  # noqa: E501
        """CreateInboxForwarderOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._field = None
        self._match = None
        self._forward_to_recipients = None
        self.discriminator = None

        self.field = field
        self.match = match
        self.forward_to_recipients = forward_to_recipients

    @property
    def field(self):
        """Gets the field of this CreateInboxForwarderOptions.  # noqa: E501

        Field to match against to trigger inbox forwarding for inbound email  # noqa: E501

        :return: The field of this CreateInboxForwarderOptions.  # noqa: E501
        :rtype: str
        """
        return self._field

    @field.setter
    def field(self, field):
        """Sets the field of this CreateInboxForwarderOptions.

        Field to match against to trigger inbox forwarding for inbound email  # noqa: E501

        :param field: The field of this CreateInboxForwarderOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and field is None:  # noqa: E501
            raise ValueError("Invalid value for `field`, must not be `None`")  # noqa: E501
        allowed_values = ["RECIPIENTS", "SENDER", "SUBJECT", "ATTACHMENTS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and field not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `field` ({0}), must be one of {1}"  # noqa: E501
                .format(field, allowed_values)
            )

        self._field = field

    @property
    def match(self):
        """Gets the match of this CreateInboxForwarderOptions.  # noqa: E501

        String or wildcard style match for field specified when evaluating forwarding rules  # noqa: E501

        :return: The match of this CreateInboxForwarderOptions.  # noqa: E501
        :rtype: str
        """
        return self._match

    @match.setter
    def match(self, match):
        """Sets the match of this CreateInboxForwarderOptions.

        String or wildcard style match for field specified when evaluating forwarding rules  # noqa: E501

        :param match: The match of this CreateInboxForwarderOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and match is None:  # noqa: E501
            raise ValueError("Invalid value for `match`, must not be `None`")  # noqa: E501

        self._match = match

    @property
    def forward_to_recipients(self):
        """Gets the forward_to_recipients of this CreateInboxForwarderOptions.  # noqa: E501

        Email addresses to forward an email to if it matches the field and match criteria of the forwarder  # noqa: E501

        :return: The forward_to_recipients of this CreateInboxForwarderOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._forward_to_recipients

    @forward_to_recipients.setter
    def forward_to_recipients(self, forward_to_recipients):
        """Sets the forward_to_recipients of this CreateInboxForwarderOptions.

        Email addresses to forward an email to if it matches the field and match criteria of the forwarder  # noqa: E501

        :param forward_to_recipients: The forward_to_recipients of this CreateInboxForwarderOptions.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and forward_to_recipients is None:  # noqa: E501
            raise ValueError("Invalid value for `forward_to_recipients`, must not be `None`")  # noqa: E501

        self._forward_to_recipients = forward_to_recipients

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CreateInboxForwarderOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CreateInboxForwarderOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/create_inbox_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CreateInboxDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'email_address': 'str',
        'domain_name': 'str',
        'domain_id': 'str',
        'name': 'str',
        'description': 'str',
        'use_domain_pool': 'bool',
        'tags': 'list[str]',
        'expires_at': 'datetime',
        'favourite': 'bool',
        'expires_in': 'int',
        'allow_team_access': 'bool',
        'inbox_type': 'str',
        'virtual_inbox': 'bool',
        'use_short_address': 'bool',
        'prefix': 'str'
    }

    attribute_map = {
        'email_address': 'emailAddress',
        'domain_name': 'domainName',
        'domain_id': 'domainId',
        'name': 'name',
        'description': 'description',
        'use_domain_pool': 'useDomainPool',
        'tags': 'tags',
        'expires_at': 'expiresAt',
        'favourite': 'favourite',
        'expires_in': 'expiresIn',
        'allow_team_access': 'allowTeamAccess',
        'inbox_type': 'inboxType',
        'virtual_inbox': 'virtualInbox',
        'use_short_address': 'useShortAddress',
        'prefix': 'prefix'
    }

    def __init__(self, email_address=None, domain_name=None, domain_id=None, name=None, description=None, use_domain_pool=None, tags=None, expires_at=None, favourite=None, expires_in=None, allow_team_access=None, inbox_type=None, virtual_inbox=None, use_short_address=None, prefix=None, local_vars_configuration=None):  # noqa: E501
        """CreateInboxDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._email_address = None
        self._domain_name = None
        self._domain_id = None
        self._name = None
        self._description = None
        self._use_domain_pool = None
        self._tags = None
        self._expires_at = None
        self._favourite = None
        self._expires_in = None
        self._allow_team_access = None
        self._inbox_type = None
        self._virtual_inbox = None
        self._use_short_address = None
        self._prefix = None
        self.discriminator = None

        self.email_address = email_address
        self.domain_name = domain_name
        self.domain_id = domain_id
        self.name = name
        self.description = description
        self.use_domain_pool = use_domain_pool
        self.tags = tags
        self.expires_at = expires_at
        self.favourite = favourite
        self.expires_in = expires_in
        self.allow_team_access = allow_team_access
        self.inbox_type = inbox_type
        self.virtual_inbox = virtual_inbox
        self.use_short_address = use_short_address
        self.prefix = prefix

    @property
    def email_address(self):
        """Gets the email_address of this CreateInboxDto.  # noqa: E501

        A custom email address to use with the inbox. Defaults to null. When null MailSlurp will assign a random email address to the inbox such as `123@mailslurp.com`. If you use the `useDomainPool` option when the email address is null it will generate an email address with a more varied domain ending such as `123@mailslurp.info` or `123@mailslurp.biz`. When a custom email address is provided the address is split into a domain and the domain is queried against your user. If you have created the domain in the MailSlurp dashboard and verified it you can use any email address that ends with the domain. Note domain types must match the inbox type - so `SMTP` inboxes will only work with `SMTP` type domains. Avoid `SMTP` inboxes if you need to send emails as they can only receive. Send an email to this address and the inbox will receive and store it for you. To retrieve the email use the Inbox and Email Controller endpoints with the inbox ID.  # noqa: E501

        :return: The email_address of this CreateInboxDto.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this CreateInboxDto.

        A custom email address to use with the inbox. Defaults to null. When null MailSlurp will assign a random email address to the inbox such as `123@mailslurp.com`. If you use the `useDomainPool` option when the email address is null it will generate an email address with a more varied domain ending such as `123@mailslurp.info` or `123@mailslurp.biz`. When a custom email address is provided the address is split into a domain and the domain is queried against your user. If you have created the domain in the MailSlurp dashboard and verified it you can use any email address that ends with the domain. Note domain types must match the inbox type - so `SMTP` inboxes will only work with `SMTP` type domains. Avoid `SMTP` inboxes if you need to send emails as they can only receive. Send an email to this address and the inbox will receive and store it for you. To retrieve the email use the Inbox and Email Controller endpoints with the inbox ID.  # noqa: E501

        :param email_address: The email_address of this CreateInboxDto.  # noqa: E501
        :type: str
        """

        self._email_address = email_address

    @property
    def domain_name(self):
        """Gets the domain_name of this CreateInboxDto.  # noqa: E501

        FQDN domain name for the domain you have verified. Will be appended with a randomly assigned recipient name. Use the `emailAddress` option instead to specify the full custom inbox.  # noqa: E501

        :return: The domain_name of this CreateInboxDto.  # noqa: E501
        :rtype: str
        """
        return self._domain_name

    @domain_name.setter
    def domain_name(self, domain_name):
        """Sets the domain_name of this CreateInboxDto.

        FQDN domain name for the domain you have verified. Will be appended with a randomly assigned recipient name. Use the `emailAddress` option instead to specify the full custom inbox.  # noqa: E501

        :param domain_name: The domain_name of this CreateInboxDto.  # noqa: E501
        :type: str
        """

        self._domain_name = domain_name

    @property
    def domain_id(self):
        """Gets the domain_id of this CreateInboxDto.  # noqa: E501

        ID of custom domain to use for email address.  # noqa: E501

        :return: The domain_id of this CreateInboxDto.  # noqa: E501
        :rtype: str
        """
        return self._domain_id

    @domain_id.setter
    def domain_id(self, domain_id):
        """Sets the domain_id of this CreateInboxDto.

        ID of custom domain to use for email address.  # noqa: E501

        :param domain_id: The domain_id of this CreateInboxDto.  # noqa: E501
        :type: str
        """

        self._domain_id = domain_id

    @property
    def name(self):
        """Gets the name of this CreateInboxDto.  # noqa: E501

        Optional name of the inbox. Displayed in the dashboard for easier search and used as the sender name when sending emails.  # noqa: E501

        :return: The name of this CreateInboxDto.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this CreateInboxDto.

        Optional name of the inbox. Displayed in the dashboard for easier search and used as the sender name when sending emails.  # noqa: E501

        :param name: The name of this CreateInboxDto.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def description(self):
        """Gets the description of this CreateInboxDto.  # noqa: E501

        Optional description of the inbox for labelling purposes. Is shown in the dashboard and can be used with  # noqa: E501

        :return: The description of this CreateInboxDto.  # noqa: E501
        :rtype: str
        """
        return self._description

    @description.setter
    def description(self, description):
        """Sets the description of this CreateInboxDto.

        Optional description of the inbox for labelling purposes. Is shown in the dashboard and can be used with  # noqa: E501

        :param description: The description of this CreateInboxDto.  # noqa: E501
        :type: str
        """

        self._description = description

    @property
    def use_domain_pool(self):
        """Gets the use_domain_pool of this CreateInboxDto.  # noqa: E501

        Use the MailSlurp domain name pool with this inbox when creating the email address. Defaults to null. If enabled the inbox will be an email address with a domain randomly chosen from a list of the MailSlurp domains. This is useful when the default `@mailslurp.com` email addresses used with inboxes are blocked or considered spam by a provider or receiving service. When domain pool is enabled an email address will be generated ending in `@mailslurp.{world,info,xyz,...}` . This means a TLD is randomly selecting from a list of `.biz`, `.info`, `.xyz` etc to add variance to the generated email addresses. When null or false MailSlurp uses the default behavior of `@mailslurp.com` or custom email address provided by the emailAddress field. Note this feature is only available for `HTTP` inbox types.  # noqa: E501

        :return: The use_domain_pool of this CreateInboxDto.  # noqa: E501
        :rtype: bool
        """
        return self._use_domain_pool

    @use_domain_pool.setter
    def use_domain_pool(self, use_domain_pool):
        """Sets the use_domain_pool of this CreateInboxDto.

        Use the MailSlurp domain name pool with this inbox when creating the email address. Defaults to null. If enabled the inbox will be an email address with a domain randomly chosen from a list of the MailSlurp domains. This is useful when the default `@mailslurp.com` email addresses used with inboxes are blocked or considered spam by a provider or receiving service. When domain pool is enabled an email address will be generated ending in `@mailslurp.{world,info,xyz,...}` . This means a TLD is randomly selecting from a list of `.biz`, `.info`, `.xyz` etc to add variance to the generated email addresses. When null or false MailSlurp uses the default behavior of `@mailslurp.com` or custom email address provided by the emailAddress field. Note this feature is only available for `HTTP` inbox types.  # noqa: E501

        :param use_domain_pool: The use_domain_pool of this CreateInboxDto.  # noqa: E501
        :type: bool
        """

        self._use_domain_pool = use_domain_pool

    @property
    def tags(self):
        """Gets the tags of this CreateInboxDto.  # noqa: E501

        Tags that inbox has been tagged with. Tags can be added to inboxes to group different inboxes within an account. You can also search for inboxes by tag in the dashboard UI.  # noqa: E501

        :return: The tags of this CreateInboxDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._tags

    @tags.setter
    def tags(self, tags):
        """Sets the tags of this CreateInboxDto.

        Tags that inbox has been tagged with. Tags can be added to inboxes to group different inboxes within an account. You can also search for inboxes by tag in the dashboard UI.  # noqa: E501

        :param tags: The tags of this CreateInboxDto.  # noqa: E501
        :type: list[str]
        """

        self._tags = tags

    @property
    def expires_at(self):
        """Gets the expires_at of this CreateInboxDto.  # noqa: E501

        Optional inbox expiration date. If null then this inbox is permanent and the emails in it won't be deleted. If an expiration date is provided or is required by your plan the inbox will be closed when the expiration time is reached. Expired inboxes still contain their emails but can no longer send or receive emails. An ExpiredInboxRecord is created when an inbox and the email address and inbox ID are recorded. The expiresAt property is a timestamp string in ISO DateTime Format yyyy-MM-dd'T'HH:mm:ss.SSSXXX.  # noqa: E501

        :return: The expires_at of this CreateInboxDto.  # noqa: E501
        :rtype: datetime
        """
        return self._expires_at

    @expires_at.setter
    def expires_at(self, expires_at):
        """Sets the expires_at of this CreateInboxDto.

        Optional inbox expiration date. If null then this inbox is permanent and the emails in it won't be deleted. If an expiration date is provided or is required by your plan the inbox will be closed when the expiration time is reached. Expired inboxes still contain their emails but can no longer send or receive emails. An ExpiredInboxRecord is created when an inbox and the email address and inbox ID are recorded. The expiresAt property is a timestamp string in ISO DateTime Format yyyy-MM-dd'T'HH:mm:ss.SSSXXX.  # noqa: E501

        :param expires_at: The expires_at of this CreateInboxDto.  # noqa: E501
        :type: datetime
        """

        self._expires_at = expires_at

    @property
    def favourite(self):
        """Gets the favourite of this CreateInboxDto.  # noqa: E501

        Is the inbox a favorite. Marking an inbox as a favorite is typically done in the dashboard for quick access or filtering  # noqa: E501

        :return: The favourite of this CreateInboxDto.  # noqa: E501
        :rtype: bool
        """
        return self._favourite

    @favourite.setter
    def favourite(self, favourite):
        """Sets the favourite of this CreateInboxDto.

        Is the inbox a favorite. Marking an inbox as a favorite is typically done in the dashboard for quick access or filtering  # noqa: E501

        :param favourite: The favourite of this CreateInboxDto.  # noqa: E501
        :type: bool
        """

        self._favourite = favourite

    @property
    def expires_in(self):
        """Gets the expires_in of this CreateInboxDto.  # noqa: E501

        Number of milliseconds that inbox should exist for  # noqa: E501

        :return: The expires_in of this CreateInboxDto.  # noqa: E501
        :rtype: int
        """
        return self._expires_in

    @expires_in.setter
    def expires_in(self, expires_in):
        """Sets the expires_in of this CreateInboxDto.

        Number of milliseconds that inbox should exist for  # noqa: E501

        :param expires_in: The expires_in of this CreateInboxDto.  # noqa: E501
        :type: int
        """

        self._expires_in = expires_in

    @property
    def allow_team_access(self):
        """Gets the allow_team_access of this CreateInboxDto.  # noqa: E501

        DEPRECATED (team access is always true). Grant team access to this inbox and the emails that belong to it for team members of your organization.  # noqa: E501

        :return: The allow_team_access of this CreateInboxDto.  # noqa: E501
        :rtype: bool
        """
        return self._allow_team_access

    @allow_team_access.setter
    def allow_team_access(self, allow_team_access):
        """Sets the allow_team_access of this CreateInboxDto.

        DEPRECATED (team access is always true). Grant team access to this inbox and the emails that belong to it for team members of your organization.  # noqa: E501

        :param allow_team_access: The allow_team_access of this CreateInboxDto.  # noqa: E501
        :type: bool
        """

        self._allow_team_access = allow_team_access

    @property
    def inbox_type(self):
        """Gets the inbox_type of this CreateInboxDto.  # noqa: E501

        Type of inbox. HTTP inboxes are faster and better for most cases. SMTP inboxes are more suited for public facing inbound messages (but cannot send).  # noqa: E501

        :return: The inbox_type of this CreateInboxDto.  # noqa: E501
        :rtype: str
        """
        return self._inbox_type

    @inbox_type.setter
    def inbox_type(self, inbox_type):
        """Sets the inbox_type of this CreateInboxDto.

        Type of inbox. HTTP inboxes are faster and better for most cases. SMTP inboxes are more suited for public facing inbound messages (but cannot send).  # noqa: E501

        :param inbox_type: The inbox_type of this CreateInboxDto.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"HTTP_INBOX", "SMTP_INBOX"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and inbox_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `inbox_type` ({0}), must be one of {1}"  # noqa: E501
                .format(inbox_type, allowed_values)
            )

        self._inbox_type = inbox_type

    @property
    def virtual_inbox(self):
        """Gets the virtual_inbox of this CreateInboxDto.  # noqa: E501

        Virtual inbox prevents any outbound emails from being sent. It creates sent email records but will never send real emails to recipients. Great for testing and faking email sending.  # noqa: E501

        :return: The virtual_inbox of this CreateInboxDto.  # noqa: E501
        :rtype: bool
        """
        return self._virtual_inbox

    @virtual_inbox.setter
    def virtual_inbox(self, virtual_inbox):
        """Sets the virtual_inbox of this CreateInboxDto.

        Virtual inbox prevents any outbound emails from being sent. It creates sent email records but will never send real emails to recipients. Great for testing and faking email sending.  # noqa: E501

        :param virtual_inbox: The virtual_inbox of this CreateInboxDto.  # noqa: E501
        :type: bool
        """

        self._virtual_inbox = virtual_inbox

    @property
    def use_short_address(self):
        """Gets the use_short_address of this CreateInboxDto.  # noqa: E501

        Use a shorter email address under 31 characters  # noqa: E501

        :return: The use_short_address of this CreateInboxDto.  # noqa: E501
        :rtype: bool
        """
        return self._use_short_address

    @use_short_address.setter
    def use_short_address(self, use_short_address):
        """Sets the use_short_address of this CreateInboxDto.

        Use a shorter email address under 31 characters  # noqa: E501

        :param use_short_address: The use_short_address of this CreateInboxDto.  # noqa: E501
        :type: bool
        """

        self._use_short_address = use_short_address

    @property
    def prefix(self):
        """Gets the prefix of this CreateInboxDto.  # noqa: E501

        Prefix to add before the email address for easier labelling or identification.  # noqa: E501

        :return: The prefix of this CreateInboxDto.  # noqa: E501
        :rtype: str
        """
        return self._prefix

    @prefix.setter
    def prefix(self, prefix):
        """Sets the prefix of this CreateInboxDto.

        Prefix to add before the email address for easier labelling or identification.  # noqa: E501

        :param prefix: The prefix of this CreateInboxDto.  # noqa: E501
        :type: str
        """

        self._prefix = prefix

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CreateInboxDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CreateInboxDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/create_group_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CreateGroupOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'name': 'str',
        'description': 'str'
    }

    attribute_map = {
        'name': 'name',
        'description': 'description'
    }

    def __init__(self, name=None, description=None, local_vars_configuration=None):  # noqa: E501
        """CreateGroupOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._name = None
        self._description = None
        self.discriminator = None

        self.name = name
        self.description = description

    @property
    def name(self):
        """Gets the name of this CreateGroupOptions.  # noqa: E501


        :return: The name of this CreateGroupOptions.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this CreateGroupOptions.


        :param name: The name of this CreateGroupOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    @property
    def description(self):
        """Gets the description of this CreateGroupOptions.  # noqa: E501


        :return: The description of this CreateGroupOptions.  # noqa: E501
        :rtype: str
        """
        return self._description

    @description.setter
    def description(self, description):
        """Sets the description of this CreateGroupOptions.


        :param description: The description of this CreateGroupOptions.  # noqa: E501
        :type: str
        """

        self._description = description

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CreateGroupOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CreateGroupOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/create_emergency_address_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CreateEmergencyAddressOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'customer_name': 'str',
        'address1': 'str',
        'city': 'str',
        'region': 'str',
        'postal_code': 'str',
        'iso_country_code': 'str',
        'display_name': 'str'
    }

    attribute_map = {
        'customer_name': 'customerName',
        'address1': 'address1',
        'city': 'city',
        'region': 'region',
        'postal_code': 'postalCode',
        'iso_country_code': 'isoCountryCode',
        'display_name': 'displayName'
    }

    def __init__(self, customer_name=None, address1=None, city=None, region=None, postal_code=None, iso_country_code=None, display_name=None, local_vars_configuration=None):  # noqa: E501
        """CreateEmergencyAddressOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._customer_name = None
        self._address1 = None
        self._city = None
        self._region = None
        self._postal_code = None
        self._iso_country_code = None
        self._display_name = None
        self.discriminator = None

        self.customer_name = customer_name
        self.address1 = address1
        self.city = city
        self.region = region
        self.postal_code = postal_code
        self.iso_country_code = iso_country_code
        if display_name is not None:
            self.display_name = display_name

    @property
    def customer_name(self):
        """Gets the customer_name of this CreateEmergencyAddressOptions.  # noqa: E501


        :return: The customer_name of this CreateEmergencyAddressOptions.  # noqa: E501
        :rtype: str
        """
        return self._customer_name

    @customer_name.setter
    def customer_name(self, customer_name):
        """Sets the customer_name of this CreateEmergencyAddressOptions.


        :param customer_name: The customer_name of this CreateEmergencyAddressOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and customer_name is None:  # noqa: E501
            raise ValueError("Invalid value for `customer_name`, must not be `None`")  # noqa: E501

        self._customer_name = customer_name

    @property
    def address1(self):
        """Gets the address1 of this CreateEmergencyAddressOptions.  # noqa: E501


        :return: The address1 of this CreateEmergencyAddressOptions.  # noqa: E501
        :rtype: str
        """
        return self._address1

    @address1.setter
    def address1(self, address1):
        """Sets the address1 of this CreateEmergencyAddressOptions.


        :param address1: The address1 of this CreateEmergencyAddressOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and address1 is None:  # noqa: E501
            raise ValueError("Invalid value for `address1`, must not be `None`")  # noqa: E501

        self._address1 = address1

    @property
    def city(self):
        """Gets the city of this CreateEmergencyAddressOptions.  # noqa: E501


        :return: The city of this CreateEmergencyAddressOptions.  # noqa: E501
        :rtype: str
        """
        return self._city

    @city.setter
    def city(self, city):
        """Sets the city of this CreateEmergencyAddressOptions.


        :param city: The city of this CreateEmergencyAddressOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and city is None:  # noqa: E501
            raise ValueError("Invalid value for `city`, must not be `None`")  # noqa: E501

        self._city = city

    @property
    def region(self):
        """Gets the region of this CreateEmergencyAddressOptions.  # noqa: E501


        :return: The region of this CreateEmergencyAddressOptions.  # noqa: E501
        :rtype: str
        """
        return self._region

    @region.setter
    def region(self, region):
        """Sets the region of this CreateEmergencyAddressOptions.


        :param region: The region of this CreateEmergencyAddressOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and region is None:  # noqa: E501
            raise ValueError("Invalid value for `region`, must not be `None`")  # noqa: E501

        self._region = region

    @property
    def postal_code(self):
        """Gets the postal_code of this CreateEmergencyAddressOptions.  # noqa: E501


        :return: The postal_code of this CreateEmergencyAddressOptions.  # noqa: E501
        :rtype: str
        """
        return self._postal_code

    @postal_code.setter
    def postal_code(self, postal_code):
        """Sets the postal_code of this CreateEmergencyAddressOptions.


        :param postal_code: The postal_code of this CreateEmergencyAddressOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and postal_code is None:  # noqa: E501
            raise ValueError("Invalid value for `postal_code`, must not be `None`")  # noqa: E501

        self._postal_code = postal_code

    @property
    def iso_country_code(self):
        """Gets the iso_country_code of this CreateEmergencyAddressOptions.  # noqa: E501


        :return: The iso_country_code of this CreateEmergencyAddressOptions.  # noqa: E501
        :rtype: str
        """
        return self._iso_country_code

    @iso_country_code.setter
    def iso_country_code(self, iso_country_code):
        """Sets the iso_country_code of this CreateEmergencyAddressOptions.


        :param iso_country_code: The iso_country_code of this CreateEmergencyAddressOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and iso_country_code is None:  # noqa: E501
            raise ValueError("Invalid value for `iso_country_code`, must not be `None`")  # noqa: E501
        allowed_values = ["US", "GB", "AU"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and iso_country_code not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `iso_country_code` ({0}), must be one of {1}"  # noqa: E501
                .format(iso_country_code, allowed_values)
            )

        self._iso_country_code = iso_country_code

    @property
    def display_name(self):
        """Gets the display_name of this CreateEmergencyAddressOptions.  # noqa: E501


        :return: The display_name of this CreateEmergencyAddressOptions.  # noqa: E501
        :rtype: str
        """
        return self._display_name

    @display_name.setter
    def display_name(self, display_name):
        """Sets the display_name of this CreateEmergencyAddressOptions.


        :param display_name: The display_name of this CreateEmergencyAddressOptions.  # noqa: E501
        :type: str
        """

        self._display_name = display_name

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CreateEmergencyAddressOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CreateEmergencyAddressOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/create_domain_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CreateDomainOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'domain': 'str',
        'description': 'str',
        'created_catch_all_inbox': 'bool',
        'domain_type': 'str'
    }

    attribute_map = {
        'domain': 'domain',
        'description': 'description',
        'created_catch_all_inbox': 'createdCatchAllInbox',
        'domain_type': 'domainType'
    }

    def __init__(self, domain=None, description=None, created_catch_all_inbox=None, domain_type=None, local_vars_configuration=None):  # noqa: E501
        """CreateDomainOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._domain = None
        self._description = None
        self._created_catch_all_inbox = None
        self._domain_type = None
        self.discriminator = None

        self.domain = domain
        self.description = description
        self.created_catch_all_inbox = created_catch_all_inbox
        self.domain_type = domain_type

    @property
    def domain(self):
        """Gets the domain of this CreateDomainOptions.  # noqa: E501

        The top level domain you wish to use with MailSlurp. Do not specify subdomain just the top level. So `test.com` covers all subdomains such as `mail.test.com`. Don't include a protocol such as `http://`. Once added you must complete the verification steps by adding the returned records to your domain.  # noqa: E501

        :return: The domain of this CreateDomainOptions.  # noqa: E501
        :rtype: str
        """
        return self._domain

    @domain.setter
    def domain(self, domain):
        """Sets the domain of this CreateDomainOptions.

        The top level domain you wish to use with MailSlurp. Do not specify subdomain just the top level. So `test.com` covers all subdomains such as `mail.test.com`. Don't include a protocol such as `http://`. Once added you must complete the verification steps by adding the returned records to your domain.  # noqa: E501

        :param domain: The domain of this CreateDomainOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and domain is None:  # noqa: E501
            raise ValueError("Invalid value for `domain`, must not be `None`")  # noqa: E501

        self._domain = domain

    @property
    def description(self):
        """Gets the description of this CreateDomainOptions.  # noqa: E501

        Optional description of the domain.  # noqa: E501

        :return: The description of this CreateDomainOptions.  # noqa: E501
        :rtype: str
        """
        return self._description

    @description.setter
    def description(self, description):
        """Sets the description of this CreateDomainOptions.

        Optional description of the domain.  # noqa: E501

        :param description: The description of this CreateDomainOptions.  # noqa: E501
        :type: str
        """

        self._description = description

    @property
    def created_catch_all_inbox(self):
        """Gets the created_catch_all_inbox of this CreateDomainOptions.  # noqa: E501

        Whether to create a catch all inbox for the domain. Any email sent to an address using your domain that cannot be matched to an existing inbox you created with the domain will be routed to the created catch all inbox. You can access emails using the regular methods on this inbox ID.  # noqa: E501

        :return: The created_catch_all_inbox of this CreateDomainOptions.  # noqa: E501
        :rtype: bool
        """
        return self._created_catch_all_inbox

    @created_catch_all_inbox.setter
    def created_catch_all_inbox(self, created_catch_all_inbox):
        """Sets the created_catch_all_inbox of this CreateDomainOptions.

        Whether to create a catch all inbox for the domain. Any email sent to an address using your domain that cannot be matched to an existing inbox you created with the domain will be routed to the created catch all inbox. You can access emails using the regular methods on this inbox ID.  # noqa: E501

        :param created_catch_all_inbox: The created_catch_all_inbox of this CreateDomainOptions.  # noqa: E501
        :type: bool
        """

        self._created_catch_all_inbox = created_catch_all_inbox

    @property
    def domain_type(self):
        """Gets the domain_type of this CreateDomainOptions.  # noqa: E501

        Type of domain. Dictates type of inbox that can be created with domain. HTTP means inboxes are processed using SES while SMTP inboxes use a custom SMTP mail server. SMTP does not support sending so use HTTP for sending emails.  # noqa: E501

        :return: The domain_type of this CreateDomainOptions.  # noqa: E501
        :rtype: str
        """
        return self._domain_type

    @domain_type.setter
    def domain_type(self, domain_type):
        """Sets the domain_type of this CreateDomainOptions.

        Type of domain. Dictates type of inbox that can be created with domain. HTTP means inboxes are processed using SES while SMTP inboxes use a custom SMTP mail server. SMTP does not support sending so use HTTP for sending emails.  # noqa: E501

        :param domain_type: The domain_type of this CreateDomainOptions.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"HTTP_INBOX", "SMTP_DOMAIN"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and domain_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `domain_type` ({0}), must be one of {1}"  # noqa: E501
                .format(domain_type, allowed_values)
            )

        self._domain_type = domain_type

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CreateDomainOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CreateDomainOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/create_contact_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CreateContactOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'first_name': 'str',
        'last_name': 'str',
        'company': 'str',
        'email_addresses': 'list[str]',
        'tags': 'list[str]',
        'meta_data': 'object',
        'opt_out': 'bool',
        'group_id': 'str',
        'verify_email_addresses': 'bool'
    }

    attribute_map = {
        'first_name': 'firstName',
        'last_name': 'lastName',
        'company': 'company',
        'email_addresses': 'emailAddresses',
        'tags': 'tags',
        'meta_data': 'metaData',
        'opt_out': 'optOut',
        'group_id': 'groupId',
        'verify_email_addresses': 'verifyEmailAddresses'
    }

    def __init__(self, first_name=None, last_name=None, company=None, email_addresses=None, tags=None, meta_data=None, opt_out=None, group_id=None, verify_email_addresses=None, local_vars_configuration=None):  # noqa: E501
        """CreateContactOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._first_name = None
        self._last_name = None
        self._company = None
        self._email_addresses = None
        self._tags = None
        self._meta_data = None
        self._opt_out = None
        self._group_id = None
        self._verify_email_addresses = None
        self.discriminator = None

        self.first_name = first_name
        self.last_name = last_name
        self.company = company
        self.email_addresses = email_addresses
        self.tags = tags
        self.meta_data = meta_data
        self.opt_out = opt_out
        self.group_id = group_id
        self.verify_email_addresses = verify_email_addresses

    @property
    def first_name(self):
        """Gets the first_name of this CreateContactOptions.  # noqa: E501


        :return: The first_name of this CreateContactOptions.  # noqa: E501
        :rtype: str
        """
        return self._first_name

    @first_name.setter
    def first_name(self, first_name):
        """Sets the first_name of this CreateContactOptions.


        :param first_name: The first_name of this CreateContactOptions.  # noqa: E501
        :type: str
        """

        self._first_name = first_name

    @property
    def last_name(self):
        """Gets the last_name of this CreateContactOptions.  # noqa: E501


        :return: The last_name of this CreateContactOptions.  # noqa: E501
        :rtype: str
        """
        return self._last_name

    @last_name.setter
    def last_name(self, last_name):
        """Sets the last_name of this CreateContactOptions.


        :param last_name: The last_name of this CreateContactOptions.  # noqa: E501
        :type: str
        """

        self._last_name = last_name

    @property
    def company(self):
        """Gets the company of this CreateContactOptions.  # noqa: E501


        :return: The company of this CreateContactOptions.  # noqa: E501
        :rtype: str
        """
        return self._company

    @company.setter
    def company(self, company):
        """Sets the company of this CreateContactOptions.


        :param company: The company of this CreateContactOptions.  # noqa: E501
        :type: str
        """

        self._company = company

    @property
    def email_addresses(self):
        """Gets the email_addresses of this CreateContactOptions.  # noqa: E501

        Set of email addresses belonging to the contact  # noqa: E501

        :return: The email_addresses of this CreateContactOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._email_addresses

    @email_addresses.setter
    def email_addresses(self, email_addresses):
        """Sets the email_addresses of this CreateContactOptions.

        Set of email addresses belonging to the contact  # noqa: E501

        :param email_addresses: The email_addresses of this CreateContactOptions.  # noqa: E501
        :type: list[str]
        """

        self._email_addresses = email_addresses

    @property
    def tags(self):
        """Gets the tags of this CreateContactOptions.  # noqa: E501

        Tags that can be used to search and group contacts  # noqa: E501

        :return: The tags of this CreateContactOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._tags

    @tags.setter
    def tags(self, tags):
        """Sets the tags of this CreateContactOptions.

        Tags that can be used to search and group contacts  # noqa: E501

        :param tags: The tags of this CreateContactOptions.  # noqa: E501
        :type: list[str]
        """

        self._tags = tags

    @property
    def meta_data(self):
        """Gets the meta_data of this CreateContactOptions.  # noqa: E501


        :return: The meta_data of this CreateContactOptions.  # noqa: E501
        :rtype: object
        """
        return self._meta_data

    @meta_data.setter
    def meta_data(self, meta_data):
        """Sets the meta_data of this CreateContactOptions.


        :param meta_data: The meta_data of this CreateContactOptions.  # noqa: E501
        :type: object
        """

        self._meta_data = meta_data

    @property
    def opt_out(self):
        """Gets the opt_out of this CreateContactOptions.  # noqa: E501

        Has the user explicitly or implicitly opted out of being contacted? If so MailSlurp will ignore them in all actions.  # noqa: E501

        :return: The opt_out of this CreateContactOptions.  # noqa: E501
        :rtype: bool
        """
        return self._opt_out

    @opt_out.setter
    def opt_out(self, opt_out):
        """Sets the opt_out of this CreateContactOptions.

        Has the user explicitly or implicitly opted out of being contacted? If so MailSlurp will ignore them in all actions.  # noqa: E501

        :param opt_out: The opt_out of this CreateContactOptions.  # noqa: E501
        :type: bool
        """

        self._opt_out = opt_out

    @property
    def group_id(self):
        """Gets the group_id of this CreateContactOptions.  # noqa: E501

        Group IDs that contact belongs to  # noqa: E501

        :return: The group_id of this CreateContactOptions.  # noqa: E501
        :rtype: str
        """
        return self._group_id

    @group_id.setter
    def group_id(self, group_id):
        """Sets the group_id of this CreateContactOptions.

        Group IDs that contact belongs to  # noqa: E501

        :param group_id: The group_id of this CreateContactOptions.  # noqa: E501
        :type: str
        """

        self._group_id = group_id

    @property
    def verify_email_addresses(self):
        """Gets the verify_email_addresses of this CreateContactOptions.  # noqa: E501

        Whether to validate contact email address exists  # noqa: E501

        :return: The verify_email_addresses of this CreateContactOptions.  # noqa: E501
        :rtype: bool
        """
        return self._verify_email_addresses

    @verify_email_addresses.setter
    def verify_email_addresses(self, verify_email_addresses):
        """Sets the verify_email_addresses of this CreateContactOptions.

        Whether to validate contact email address exists  # noqa: E501

        :param verify_email_addresses: The verify_email_addresses of this CreateContactOptions.  # noqa: E501
        :type: bool
        """

        self._verify_email_addresses = verify_email_addresses

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CreateContactOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CreateContactOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/create_connector_smtp_connection_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CreateConnectorSmtpConnectionOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'enabled': 'bool',
        'smtp_host': 'str',
        'smtp_port': 'int',
        'smtp_ssl': 'bool',
        'smtp_username': 'str',
        'smtp_password': 'str'
    }

    attribute_map = {
        'enabled': 'enabled',
        'smtp_host': 'smtpHost',
        'smtp_port': 'smtpPort',
        'smtp_ssl': 'smtpSsl',
        'smtp_username': 'smtpUsername',
        'smtp_password': 'smtpPassword'
    }

    def __init__(self, enabled=None, smtp_host=None, smtp_port=None, smtp_ssl=None, smtp_username=None, smtp_password=None, local_vars_configuration=None):  # noqa: E501
        """CreateConnectorSmtpConnectionOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._enabled = None
        self._smtp_host = None
        self._smtp_port = None
        self._smtp_ssl = None
        self._smtp_username = None
        self._smtp_password = None
        self.discriminator = None

        if enabled is not None:
            self.enabled = enabled
        self.smtp_host = smtp_host
        if smtp_port is not None:
            self.smtp_port = smtp_port
        if smtp_ssl is not None:
            self.smtp_ssl = smtp_ssl
        if smtp_username is not None:
            self.smtp_username = smtp_username
        if smtp_password is not None:
            self.smtp_password = smtp_password

    @property
    def enabled(self):
        """Gets the enabled of this CreateConnectorSmtpConnectionOptions.  # noqa: E501


        :return: The enabled of this CreateConnectorSmtpConnectionOptions.  # noqa: E501
        :rtype: bool
        """
        return self._enabled

    @enabled.setter
    def enabled(self, enabled):
        """Sets the enabled of this CreateConnectorSmtpConnectionOptions.


        :param enabled: The enabled of this CreateConnectorSmtpConnectionOptions.  # noqa: E501
        :type: bool
        """

        self._enabled = enabled

    @property
    def smtp_host(self):
        """Gets the smtp_host of this CreateConnectorSmtpConnectionOptions.  # noqa: E501


        :return: The smtp_host of this CreateConnectorSmtpConnectionOptions.  # noqa: E501
        :rtype: str
        """
        return self._smtp_host

    @smtp_host.setter
    def smtp_host(self, smtp_host):
        """Sets the smtp_host of this CreateConnectorSmtpConnectionOptions.


        :param smtp_host: The smtp_host of this CreateConnectorSmtpConnectionOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and smtp_host is None:  # noqa: E501
            raise ValueError("Invalid value for `smtp_host`, must not be `None`")  # noqa: E501

        self._smtp_host = smtp_host

    @property
    def smtp_port(self):
        """Gets the smtp_port of this CreateConnectorSmtpConnectionOptions.  # noqa: E501


        :return: The smtp_port of this CreateConnectorSmtpConnectionOptions.  # noqa: E501
        :rtype: int
        """
        return self._smtp_port

    @smtp_port.setter
    def smtp_port(self, smtp_port):
        """Sets the smtp_port of this CreateConnectorSmtpConnectionOptions.


        :param smtp_port: The smtp_port of this CreateConnectorSmtpConnectionOptions.  # noqa: E501
        :type: int
        """

        self._smtp_port = smtp_port

    @property
    def smtp_ssl(self):
        """Gets the smtp_ssl of this CreateConnectorSmtpConnectionOptions.  # noqa: E501


        :return: The smtp_ssl of this CreateConnectorSmtpConnectionOptions.  # noqa: E501
        :rtype: bool
        """
        return self._smtp_ssl

    @smtp_ssl.setter
    def smtp_ssl(self, smtp_ssl):
        """Sets the smtp_ssl of this CreateConnectorSmtpConnectionOptions.


        :param smtp_ssl: The smtp_ssl of this CreateConnectorSmtpConnectionOptions.  # noqa: E501
        :type: bool
        """

        self._smtp_ssl = smtp_ssl

    @property
    def smtp_username(self):
        """Gets the smtp_username of this CreateConnectorSmtpConnectionOptions.  # noqa: E501


        :return: The smtp_username of this CreateConnectorSmtpConnectionOptions.  # noqa: E501
        :rtype: str
        """
        return self._smtp_username

    @smtp_username.setter
    def smtp_username(self, smtp_username):
        """Sets the smtp_username of this CreateConnectorSmtpConnectionOptions.


        :param smtp_username: The smtp_username of this CreateConnectorSmtpConnectionOptions.  # noqa: E501
        :type: str
        """

        self._smtp_username = smtp_username

    @property
    def smtp_password(self):
        """Gets the smtp_password of this CreateConnectorSmtpConnectionOptions.  # noqa: E501


        :return: The smtp_password of this CreateConnectorSmtpConnectionOptions.  # noqa: E501
        :rtype: str
        """
        return self._smtp_password

    @smtp_password.setter
    def smtp_password(self, smtp_password):
        """Sets the smtp_password of this CreateConnectorSmtpConnectionOptions.


        :param smtp_password: The smtp_password of this CreateConnectorSmtpConnectionOptions.  # noqa: E501
        :type: str
        """

        self._smtp_password = smtp_password

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CreateConnectorSmtpConnectionOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CreateConnectorSmtpConnectionOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/create_connector_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CreateConnectorOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'sync_enabled': 'bool',
        'sync_schedule_type': 'str',
        'sync_interval': 'int',
        'name': 'str',
        'email_address': 'str',
        'enabled': 'bool'
    }

    attribute_map = {
        'sync_enabled': 'syncEnabled',
        'sync_schedule_type': 'syncScheduleType',
        'sync_interval': 'syncInterval',
        'name': 'name',
        'email_address': 'emailAddress',
        'enabled': 'enabled'
    }

    def __init__(self, sync_enabled=None, sync_schedule_type=None, sync_interval=None, name=None, email_address=None, enabled=None, local_vars_configuration=None):  # noqa: E501
        """CreateConnectorOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._sync_enabled = None
        self._sync_schedule_type = None
        self._sync_interval = None
        self._name = None
        self._email_address = None
        self._enabled = None
        self.discriminator = None

        self.sync_enabled = sync_enabled
        self.sync_schedule_type = sync_schedule_type
        self.sync_interval = sync_interval
        self.name = name
        self.email_address = email_address
        self.enabled = enabled

    @property
    def sync_enabled(self):
        """Gets the sync_enabled of this CreateConnectorOptions.  # noqa: E501

        Enable automatic background sync  # noqa: E501

        :return: The sync_enabled of this CreateConnectorOptions.  # noqa: E501
        :rtype: bool
        """
        return self._sync_enabled

    @sync_enabled.setter
    def sync_enabled(self, sync_enabled):
        """Sets the sync_enabled of this CreateConnectorOptions.

        Enable automatic background sync  # noqa: E501

        :param sync_enabled: The sync_enabled of this CreateConnectorOptions.  # noqa: E501
        :type: bool
        """

        self._sync_enabled = sync_enabled

    @property
    def sync_schedule_type(self):
        """Gets the sync_schedule_type of this CreateConnectorOptions.  # noqa: E501

        Sync schedule type  # noqa: E501

        :return: The sync_schedule_type of this CreateConnectorOptions.  # noqa: E501
        :rtype: str
        """
        return self._sync_schedule_type

    @sync_schedule_type.setter
    def sync_schedule_type(self, sync_schedule_type):
        """Sets the sync_schedule_type of this CreateConnectorOptions.

        Sync schedule type  # noqa: E501

        :param sync_schedule_type: The sync_schedule_type of this CreateConnectorOptions.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"INTERVAL"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and sync_schedule_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `sync_schedule_type` ({0}), must be one of {1}"  # noqa: E501
                .format(sync_schedule_type, allowed_values)
            )

        self._sync_schedule_type = sync_schedule_type

    @property
    def sync_interval(self):
        """Gets the sync_interval of this CreateConnectorOptions.  # noqa: E501

        Sync interval in minutes  # noqa: E501

        :return: The sync_interval of this CreateConnectorOptions.  # noqa: E501
        :rtype: int
        """
        return self._sync_interval

    @sync_interval.setter
    def sync_interval(self, sync_interval):
        """Sets the sync_interval of this CreateConnectorOptions.

        Sync interval in minutes  # noqa: E501

        :param sync_interval: The sync_interval of this CreateConnectorOptions.  # noqa: E501
        :type: int
        """

        self._sync_interval = sync_interval

    @property
    def name(self):
        """Gets the name of this CreateConnectorOptions.  # noqa: E501

        Name of connector  # noqa: E501

        :return: The name of this CreateConnectorOptions.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this CreateConnectorOptions.

        Name of connector  # noqa: E501

        :param name: The name of this CreateConnectorOptions.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def email_address(self):
        """Gets the email_address of this CreateConnectorOptions.  # noqa: E501

        Email address of external inbox  # noqa: E501

        :return: The email_address of this CreateConnectorOptions.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this CreateConnectorOptions.

        Email address of external inbox  # noqa: E501

        :param email_address: The email_address of this CreateConnectorOptions.  # noqa: E501
        :type: str
        """

        self._email_address = email_address

    @property
    def enabled(self):
        """Gets the enabled of this CreateConnectorOptions.  # noqa: E501

        Is connector enabled  # noqa: E501

        :return: The enabled of this CreateConnectorOptions.  # noqa: E501
        :rtype: bool
        """
        return self._enabled

    @enabled.setter
    def enabled(self, enabled):
        """Sets the enabled of this CreateConnectorOptions.

        Is connector enabled  # noqa: E501

        :param enabled: The enabled of this CreateConnectorOptions.  # noqa: E501
        :type: bool
        """

        self._enabled = enabled

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CreateConnectorOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CreateConnectorOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/create_connector_imap_connection_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CreateConnectorImapConnectionOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'imap_ssl': 'bool',
        'imap_username': 'str',
        'imap_password': 'str',
        'select_folder': 'str',
        'search_terms': 'str',
        'imap_port': 'int',
        'imap_host': 'str',
        'enabled': 'bool'
    }

    attribute_map = {
        'imap_ssl': 'imapSsl',
        'imap_username': 'imapUsername',
        'imap_password': 'imapPassword',
        'select_folder': 'selectFolder',
        'search_terms': 'searchTerms',
        'imap_port': 'imapPort',
        'imap_host': 'imapHost',
        'enabled': 'enabled'
    }

    def __init__(self, imap_ssl=None, imap_username=None, imap_password=None, select_folder=None, search_terms=None, imap_port=None, imap_host=None, enabled=None, local_vars_configuration=None):  # noqa: E501
        """CreateConnectorImapConnectionOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._imap_ssl = None
        self._imap_username = None
        self._imap_password = None
        self._select_folder = None
        self._search_terms = None
        self._imap_port = None
        self._imap_host = None
        self._enabled = None
        self.discriminator = None

        self.imap_ssl = imap_ssl
        self.imap_username = imap_username
        self.imap_password = imap_password
        self.select_folder = select_folder
        self.search_terms = search_terms
        self.imap_port = imap_port
        self.imap_host = imap_host
        self.enabled = enabled

    @property
    def imap_ssl(self):
        """Gets the imap_ssl of this CreateConnectorImapConnectionOptions.  # noqa: E501


        :return: The imap_ssl of this CreateConnectorImapConnectionOptions.  # noqa: E501
        :rtype: bool
        """
        return self._imap_ssl

    @imap_ssl.setter
    def imap_ssl(self, imap_ssl):
        """Sets the imap_ssl of this CreateConnectorImapConnectionOptions.


        :param imap_ssl: The imap_ssl of this CreateConnectorImapConnectionOptions.  # noqa: E501
        :type: bool
        """

        self._imap_ssl = imap_ssl

    @property
    def imap_username(self):
        """Gets the imap_username of this CreateConnectorImapConnectionOptions.  # noqa: E501


        :return: The imap_username of this CreateConnectorImapConnectionOptions.  # noqa: E501
        :rtype: str
        """
        return self._imap_username

    @imap_username.setter
    def imap_username(self, imap_username):
        """Sets the imap_username of this CreateConnectorImapConnectionOptions.


        :param imap_username: The imap_username of this CreateConnectorImapConnectionOptions.  # noqa: E501
        :type: str
        """

        self._imap_username = imap_username

    @property
    def imap_password(self):
        """Gets the imap_password of this CreateConnectorImapConnectionOptions.  # noqa: E501


        :return: The imap_password of this CreateConnectorImapConnectionOptions.  # noqa: E501
        :rtype: str
        """
        return self._imap_password

    @imap_password.setter
    def imap_password(self, imap_password):
        """Sets the imap_password of this CreateConnectorImapConnectionOptions.


        :param imap_password: The imap_password of this CreateConnectorImapConnectionOptions.  # noqa: E501
        :type: str
        """

        self._imap_password = imap_password

    @property
    def select_folder(self):
        """Gets the select_folder of this CreateConnectorImapConnectionOptions.  # noqa: E501

        Optional folder to select during IMAP connection  # noqa: E501

        :return: The select_folder of this CreateConnectorImapConnectionOptions.  # noqa: E501
        :rtype: str
        """
        return self._select_folder

    @select_folder.setter
    def select_folder(self, select_folder):
        """Sets the select_folder of this CreateConnectorImapConnectionOptions.

        Optional folder to select during IMAP connection  # noqa: E501

        :param select_folder: The select_folder of this CreateConnectorImapConnectionOptions.  # noqa: E501
        :type: str
        """

        self._select_folder = select_folder

    @property
    def search_terms(self):
        """Gets the search_terms of this CreateConnectorImapConnectionOptions.  # noqa: E501


        :return: The search_terms of this CreateConnectorImapConnectionOptions.  # noqa: E501
        :rtype: str
        """
        return self._search_terms

    @search_terms.setter
    def search_terms(self, search_terms):
        """Sets the search_terms of this CreateConnectorImapConnectionOptions.


        :param search_terms: The search_terms of this CreateConnectorImapConnectionOptions.  # noqa: E501
        :type: str
        """

        self._search_terms = search_terms

    @property
    def imap_port(self):
        """Gets the imap_port of this CreateConnectorImapConnectionOptions.  # noqa: E501

        IMAP server port  # noqa: E501

        :return: The imap_port of this CreateConnectorImapConnectionOptions.  # noqa: E501
        :rtype: int
        """
        return self._imap_port

    @imap_port.setter
    def imap_port(self, imap_port):
        """Sets the imap_port of this CreateConnectorImapConnectionOptions.

        IMAP server port  # noqa: E501

        :param imap_port: The imap_port of this CreateConnectorImapConnectionOptions.  # noqa: E501
        :type: int
        """

        self._imap_port = imap_port

    @property
    def imap_host(self):
        """Gets the imap_host of this CreateConnectorImapConnectionOptions.  # noqa: E501

        IMAP server host  # noqa: E501

        :return: The imap_host of this CreateConnectorImapConnectionOptions.  # noqa: E501
        :rtype: str
        """
        return self._imap_host

    @imap_host.setter
    def imap_host(self, imap_host):
        """Sets the imap_host of this CreateConnectorImapConnectionOptions.

        IMAP server host  # noqa: E501

        :param imap_host: The imap_host of this CreateConnectorImapConnectionOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and imap_host is None:  # noqa: E501
            raise ValueError("Invalid value for `imap_host`, must not be `None`")  # noqa: E501

        self._imap_host = imap_host

    @property
    def enabled(self):
        """Gets the enabled of this CreateConnectorImapConnectionOptions.  # noqa: E501

        IMAP server enabled  # noqa: E501

        :return: The enabled of this CreateConnectorImapConnectionOptions.  # noqa: E501
        :rtype: bool
        """
        return self._enabled

    @enabled.setter
    def enabled(self, enabled):
        """Sets the enabled of this CreateConnectorImapConnectionOptions.

        IMAP server enabled  # noqa: E501

        :param enabled: The enabled of this CreateConnectorImapConnectionOptions.  # noqa: E501
        :type: bool
        """

        self._enabled = enabled

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CreateConnectorImapConnectionOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CreateConnectorImapConnectionOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/create_alias_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CreateAliasOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'email_address': 'str',
        'inbox_id': 'str',
        'name': 'str',
        'use_threads': 'bool',
        'domain_id': 'str',
        'verify_email_address': 'bool'
    }

    attribute_map = {
        'email_address': 'emailAddress',
        'inbox_id': 'inboxId',
        'name': 'name',
        'use_threads': 'useThreads',
        'domain_id': 'domainId',
        'verify_email_address': 'verifyEmailAddress'
    }

    def __init__(self, email_address=None, inbox_id=None, name=None, use_threads=None, domain_id=None, verify_email_address=None, local_vars_configuration=None):  # noqa: E501
        """CreateAliasOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._email_address = None
        self._inbox_id = None
        self._name = None
        self._use_threads = None
        self._domain_id = None
        self._verify_email_address = None
        self.discriminator = None

        self.email_address = email_address
        self.inbox_id = inbox_id
        self.name = name
        self.use_threads = use_threads
        self.domain_id = domain_id
        self.verify_email_address = verify_email_address

    @property
    def email_address(self):
        """Gets the email_address of this CreateAliasOptions.  # noqa: E501

        Email address to be hidden behind alias. Emails sent to the alias email address will be forwarded to this address. If you want to enable replies set useThreads true and the reply-to for the email will allow outbound communication via a thread. Some email addresses may require verification if they are not added as a contact first.  # noqa: E501

        :return: The email_address of this CreateAliasOptions.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this CreateAliasOptions.

        Email address to be hidden behind alias. Emails sent to the alias email address will be forwarded to this address. If you want to enable replies set useThreads true and the reply-to for the email will allow outbound communication via a thread. Some email addresses may require verification if they are not added as a contact first.  # noqa: E501

        :param email_address: The email_address of this CreateAliasOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    @property
    def inbox_id(self):
        """Gets the inbox_id of this CreateAliasOptions.  # noqa: E501

        Optional inbox ID to attach to alias. Null by default means an a new inbox will be created for the alias. Use a custom inbox to control what email address the alias uses. To use custom email addresses create a domain and an inbox, the use the inbox ID with this call. Emails received by this inbox will be forwarded to the alias email address  # noqa: E501

        :return: The inbox_id of this CreateAliasOptions.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this CreateAliasOptions.

        Optional inbox ID to attach to alias. Null by default means an a new inbox will be created for the alias. Use a custom inbox to control what email address the alias uses. To use custom email addresses create a domain and an inbox, the use the inbox ID with this call. Emails received by this inbox will be forwarded to the alias email address  # noqa: E501

        :param inbox_id: The inbox_id of this CreateAliasOptions.  # noqa: E501
        :type: str
        """

        self._inbox_id = inbox_id

    @property
    def name(self):
        """Gets the name of this CreateAliasOptions.  # noqa: E501

        Optional name for alias  # noqa: E501

        :return: The name of this CreateAliasOptions.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this CreateAliasOptions.

        Optional name for alias  # noqa: E501

        :param name: The name of this CreateAliasOptions.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def use_threads(self):
        """Gets the use_threads of this CreateAliasOptions.  # noqa: E501

        Enable threads options. If true emails will be sent with a unique reply-to thread address. This means you can reply to the forwarded email and it will be sent to the recipients via your alias address. That way a thread conversation is preserved.  # noqa: E501

        :return: The use_threads of this CreateAliasOptions.  # noqa: E501
        :rtype: bool
        """
        return self._use_threads

    @use_threads.setter
    def use_threads(self, use_threads):
        """Sets the use_threads of this CreateAliasOptions.

        Enable threads options. If true emails will be sent with a unique reply-to thread address. This means you can reply to the forwarded email and it will be sent to the recipients via your alias address. That way a thread conversation is preserved.  # noqa: E501

        :param use_threads: The use_threads of this CreateAliasOptions.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and use_threads is None:  # noqa: E501
            raise ValueError("Invalid value for `use_threads`, must not be `None`")  # noqa: E501

        self._use_threads = use_threads

    @property
    def domain_id(self):
        """Gets the domain_id of this CreateAliasOptions.  # noqa: E501

        Custom domain ID to use when generating alias email addresses  # noqa: E501

        :return: The domain_id of this CreateAliasOptions.  # noqa: E501
        :rtype: str
        """
        return self._domain_id

    @domain_id.setter
    def domain_id(self, domain_id):
        """Sets the domain_id of this CreateAliasOptions.

        Custom domain ID to use when generating alias email addresses  # noqa: E501

        :param domain_id: The domain_id of this CreateAliasOptions.  # noqa: E501
        :type: str
        """

        self._domain_id = domain_id

    @property
    def verify_email_address(self):
        """Gets the verify_email_address of this CreateAliasOptions.  # noqa: E501

        Whether to verify the masked email address exists before sending an email to it  # noqa: E501

        :return: The verify_email_address of this CreateAliasOptions.  # noqa: E501
        :rtype: bool
        """
        return self._verify_email_address

    @verify_email_address.setter
    def verify_email_address(self, verify_email_address):
        """Sets the verify_email_address of this CreateAliasOptions.

        Whether to verify the masked email address exists before sending an email to it  # noqa: E501

        :param verify_email_address: The verify_email_address of this CreateAliasOptions.  # noqa: E501
        :type: bool
        """

        self._verify_email_address = verify_email_address

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CreateAliasOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CreateAliasOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/count_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CountDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'total_elements': 'int'
    }

    attribute_map = {
        'total_elements': 'totalElements'
    }

    def __init__(self, total_elements=None, local_vars_configuration=None):  # noqa: E501
        """CountDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._total_elements = None
        self.discriminator = None

        self.total_elements = total_elements

    @property
    def total_elements(self):
        """Gets the total_elements of this CountDto.  # noqa: E501


        :return: The total_elements of this CountDto.  # noqa: E501
        :rtype: int
        """
        return self._total_elements

    @total_elements.setter
    def total_elements(self, total_elements):
        """Sets the total_elements of this CountDto.


        :param total_elements: The total_elements of this CountDto.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and total_elements is None:  # noqa: E501
            raise ValueError("Invalid value for `total_elements`, must not be `None`")  # noqa: E501

        self._total_elements = total_elements

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CountDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CountDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/content_match_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ContentMatchOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'pattern': 'str'
    }

    attribute_map = {
        'pattern': 'pattern'
    }

    def __init__(self, pattern=None, local_vars_configuration=None):  # noqa: E501
        """ContentMatchOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._pattern = None
        self.discriminator = None

        self.pattern = pattern

    @property
    def pattern(self):
        """Gets the pattern of this ContentMatchOptions.  # noqa: E501

        Java style regex pattern. Do not include the typical `/` at start or end of regex in some languages. Given an example `your code is: 12345` the pattern to extract match looks like `code is: (\\d{6})`. This will return an array of matches with the first matching the entire pattern and the subsequent matching the groups: `['code is: 123456', '123456']` See https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html for more information of available patterns.  # noqa: E501

        :return: The pattern of this ContentMatchOptions.  # noqa: E501
        :rtype: str
        """
        return self._pattern

    @pattern.setter
    def pattern(self, pattern):
        """Sets the pattern of this ContentMatchOptions.

        Java style regex pattern. Do not include the typical `/` at start or end of regex in some languages. Given an example `your code is: 12345` the pattern to extract match looks like `code is: (\\d{6})`. This will return an array of matches with the first matching the entire pattern and the subsequent matching the groups: `['code is: 123456', '123456']` See https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html for more information of available patterns.  # noqa: E501

        :param pattern: The pattern of this ContentMatchOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and pattern is None:  # noqa: E501
            raise ValueError("Invalid value for `pattern`, must not be `None`")  # noqa: E501

        self._pattern = pattern

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ContentMatchOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ContentMatchOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/contact_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ContactProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'email_address': 'str',
        'email_addresses': 'list[str]',
        'first_name': 'str',
        'last_name': 'str',
        'company': 'str',
        'opt_out': 'bool',
        'id': 'str',
        'group_id': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'email_address': 'emailAddress',
        'email_addresses': 'emailAddresses',
        'first_name': 'firstName',
        'last_name': 'lastName',
        'company': 'company',
        'opt_out': 'optOut',
        'id': 'id',
        'group_id': 'groupId'
    }

    def __init__(self, created_at=None, email_address=None, email_addresses=None, first_name=None, last_name=None, company=None, opt_out=None, id=None, group_id=None, local_vars_configuration=None):  # noqa: E501
        """ContactProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._email_address = None
        self._email_addresses = None
        self._first_name = None
        self._last_name = None
        self._company = None
        self._opt_out = None
        self._id = None
        self._group_id = None
        self.discriminator = None

        self.created_at = created_at
        self.email_address = email_address
        self.email_addresses = email_addresses
        self.first_name = first_name
        self.last_name = last_name
        self.company = company
        self.opt_out = opt_out
        self.id = id
        self.group_id = group_id

    @property
    def created_at(self):
        """Gets the created_at of this ContactProjection.  # noqa: E501


        :return: The created_at of this ContactProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this ContactProjection.


        :param created_at: The created_at of this ContactProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def email_address(self):
        """Gets the email_address of this ContactProjection.  # noqa: E501


        :return: The email_address of this ContactProjection.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this ContactProjection.


        :param email_address: The email_address of this ContactProjection.  # noqa: E501
        :type: str
        """

        self._email_address = email_address

    @property
    def email_addresses(self):
        """Gets the email_addresses of this ContactProjection.  # noqa: E501


        :return: The email_addresses of this ContactProjection.  # noqa: E501
        :rtype: list[str]
        """
        return self._email_addresses

    @email_addresses.setter
    def email_addresses(self, email_addresses):
        """Sets the email_addresses of this ContactProjection.


        :param email_addresses: The email_addresses of this ContactProjection.  # noqa: E501
        :type: list[str]
        """

        self._email_addresses = email_addresses

    @property
    def first_name(self):
        """Gets the first_name of this ContactProjection.  # noqa: E501


        :return: The first_name of this ContactProjection.  # noqa: E501
        :rtype: str
        """
        return self._first_name

    @first_name.setter
    def first_name(self, first_name):
        """Sets the first_name of this ContactProjection.


        :param first_name: The first_name of this ContactProjection.  # noqa: E501
        :type: str
        """

        self._first_name = first_name

    @property
    def last_name(self):
        """Gets the last_name of this ContactProjection.  # noqa: E501


        :return: The last_name of this ContactProjection.  # noqa: E501
        :rtype: str
        """
        return self._last_name

    @last_name.setter
    def last_name(self, last_name):
        """Sets the last_name of this ContactProjection.


        :param last_name: The last_name of this ContactProjection.  # noqa: E501
        :type: str
        """

        self._last_name = last_name

    @property
    def company(self):
        """Gets the company of this ContactProjection.  # noqa: E501


        :return: The company of this ContactProjection.  # noqa: E501
        :rtype: str
        """
        return self._company

    @company.setter
    def company(self, company):
        """Sets the company of this ContactProjection.


        :param company: The company of this ContactProjection.  # noqa: E501
        :type: str
        """

        self._company = company

    @property
    def opt_out(self):
        """Gets the opt_out of this ContactProjection.  # noqa: E501


        :return: The opt_out of this ContactProjection.  # noqa: E501
        :rtype: bool
        """
        return self._opt_out

    @opt_out.setter
    def opt_out(self, opt_out):
        """Sets the opt_out of this ContactProjection.


        :param opt_out: The opt_out of this ContactProjection.  # noqa: E501
        :type: bool
        """

        self._opt_out = opt_out

    @property
    def id(self):
        """Gets the id of this ContactProjection.  # noqa: E501


        :return: The id of this ContactProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this ContactProjection.


        :param id: The id of this ContactProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def group_id(self):
        """Gets the group_id of this ContactProjection.  # noqa: E501


        :return: The group_id of this ContactProjection.  # noqa: E501
        :rtype: str
        """
        return self._group_id

    @group_id.setter
    def group_id(self, group_id):
        """Sets the group_id of this ContactProjection.


        :param group_id: The group_id of this ContactProjection.  # noqa: E501
        :type: str
        """

        self._group_id = group_id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ContactProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ContactProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/contact_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ContactDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'group_id': 'str',
        'first_name': 'str',
        'last_name': 'str',
        'company': 'str',
        'email_addresses': 'list[str]',
        'primary_email_address': 'str',
        'tags': 'list[str]',
        'meta_data': 'object',
        'opt_out': 'bool',
        'created_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'group_id': 'groupId',
        'first_name': 'firstName',
        'last_name': 'lastName',
        'company': 'company',
        'email_addresses': 'emailAddresses',
        'primary_email_address': 'primaryEmailAddress',
        'tags': 'tags',
        'meta_data': 'metaData',
        'opt_out': 'optOut',
        'created_at': 'createdAt'
    }

    def __init__(self, id=None, group_id=None, first_name=None, last_name=None, company=None, email_addresses=None, primary_email_address=None, tags=None, meta_data=None, opt_out=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """ContactDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._group_id = None
        self._first_name = None
        self._last_name = None
        self._company = None
        self._email_addresses = None
        self._primary_email_address = None
        self._tags = None
        self._meta_data = None
        self._opt_out = None
        self._created_at = None
        self.discriminator = None

        self.id = id
        self.group_id = group_id
        self.first_name = first_name
        self.last_name = last_name
        self.company = company
        self.email_addresses = email_addresses
        self.primary_email_address = primary_email_address
        self.tags = tags
        self.meta_data = meta_data
        self.opt_out = opt_out
        self.created_at = created_at

    @property
    def id(self):
        """Gets the id of this ContactDto.  # noqa: E501


        :return: The id of this ContactDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this ContactDto.


        :param id: The id of this ContactDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def group_id(self):
        """Gets the group_id of this ContactDto.  # noqa: E501


        :return: The group_id of this ContactDto.  # noqa: E501
        :rtype: str
        """
        return self._group_id

    @group_id.setter
    def group_id(self, group_id):
        """Sets the group_id of this ContactDto.


        :param group_id: The group_id of this ContactDto.  # noqa: E501
        :type: str
        """

        self._group_id = group_id

    @property
    def first_name(self):
        """Gets the first_name of this ContactDto.  # noqa: E501


        :return: The first_name of this ContactDto.  # noqa: E501
        :rtype: str
        """
        return self._first_name

    @first_name.setter
    def first_name(self, first_name):
        """Sets the first_name of this ContactDto.


        :param first_name: The first_name of this ContactDto.  # noqa: E501
        :type: str
        """

        self._first_name = first_name

    @property
    def last_name(self):
        """Gets the last_name of this ContactDto.  # noqa: E501


        :return: The last_name of this ContactDto.  # noqa: E501
        :rtype: str
        """
        return self._last_name

    @last_name.setter
    def last_name(self, last_name):
        """Sets the last_name of this ContactDto.


        :param last_name: The last_name of this ContactDto.  # noqa: E501
        :type: str
        """

        self._last_name = last_name

    @property
    def company(self):
        """Gets the company of this ContactDto.  # noqa: E501


        :return: The company of this ContactDto.  # noqa: E501
        :rtype: str
        """
        return self._company

    @company.setter
    def company(self, company):
        """Sets the company of this ContactDto.


        :param company: The company of this ContactDto.  # noqa: E501
        :type: str
        """

        self._company = company

    @property
    def email_addresses(self):
        """Gets the email_addresses of this ContactDto.  # noqa: E501


        :return: The email_addresses of this ContactDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._email_addresses

    @email_addresses.setter
    def email_addresses(self, email_addresses):
        """Sets the email_addresses of this ContactDto.


        :param email_addresses: The email_addresses of this ContactDto.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and email_addresses is None:  # noqa: E501
            raise ValueError("Invalid value for `email_addresses`, must not be `None`")  # noqa: E501

        self._email_addresses = email_addresses

    @property
    def primary_email_address(self):
        """Gets the primary_email_address of this ContactDto.  # noqa: E501


        :return: The primary_email_address of this ContactDto.  # noqa: E501
        :rtype: str
        """
        return self._primary_email_address

    @primary_email_address.setter
    def primary_email_address(self, primary_email_address):
        """Sets the primary_email_address of this ContactDto.


        :param primary_email_address: The primary_email_address of this ContactDto.  # noqa: E501
        :type: str
        """

        self._primary_email_address = primary_email_address

    @property
    def tags(self):
        """Gets the tags of this ContactDto.  # noqa: E501


        :return: The tags of this ContactDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._tags

    @tags.setter
    def tags(self, tags):
        """Sets the tags of this ContactDto.


        :param tags: The tags of this ContactDto.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and tags is None:  # noqa: E501
            raise ValueError("Invalid value for `tags`, must not be `None`")  # noqa: E501

        self._tags = tags

    @property
    def meta_data(self):
        """Gets the meta_data of this ContactDto.  # noqa: E501


        :return: The meta_data of this ContactDto.  # noqa: E501
        :rtype: object
        """
        return self._meta_data

    @meta_data.setter
    def meta_data(self, meta_data):
        """Sets the meta_data of this ContactDto.


        :param meta_data: The meta_data of this ContactDto.  # noqa: E501
        :type: object
        """

        self._meta_data = meta_data

    @property
    def opt_out(self):
        """Gets the opt_out of this ContactDto.  # noqa: E501


        :return: The opt_out of this ContactDto.  # noqa: E501
        :rtype: bool
        """
        return self._opt_out

    @opt_out.setter
    def opt_out(self, opt_out):
        """Sets the opt_out of this ContactDto.


        :param opt_out: The opt_out of this ContactDto.  # noqa: E501
        :type: bool
        """

        self._opt_out = opt_out

    @property
    def created_at(self):
        """Gets the created_at of this ContactDto.  # noqa: E501


        :return: The created_at of this ContactDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this ContactDto.


        :param created_at: The created_at of this ContactDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ContactDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ContactDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/connector_sync_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ConnectorSyncResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'email_sync_count': 'int',
        'log_lines': 'list[str]'
    }

    attribute_map = {
        'email_sync_count': 'emailSyncCount',
        'log_lines': 'logLines'
    }

    def __init__(self, email_sync_count=None, log_lines=None, local_vars_configuration=None):  # noqa: E501
        """ConnectorSyncResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._email_sync_count = None
        self._log_lines = None
        self.discriminator = None

        self.email_sync_count = email_sync_count
        if log_lines is not None:
            self.log_lines = log_lines

    @property
    def email_sync_count(self):
        """Gets the email_sync_count of this ConnectorSyncResult.  # noqa: E501


        :return: The email_sync_count of this ConnectorSyncResult.  # noqa: E501
        :rtype: int
        """
        return self._email_sync_count

    @email_sync_count.setter
    def email_sync_count(self, email_sync_count):
        """Sets the email_sync_count of this ConnectorSyncResult.


        :param email_sync_count: The email_sync_count of this ConnectorSyncResult.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and email_sync_count is None:  # noqa: E501
            raise ValueError("Invalid value for `email_sync_count`, must not be `None`")  # noqa: E501

        self._email_sync_count = email_sync_count

    @property
    def log_lines(self):
        """Gets the log_lines of this ConnectorSyncResult.  # noqa: E501


        :return: The log_lines of this ConnectorSyncResult.  # noqa: E501
        :rtype: list[str]
        """
        return self._log_lines

    @log_lines.setter
    def log_lines(self, log_lines):
        """Sets the log_lines of this ConnectorSyncResult.


        :param log_lines: The log_lines of this ConnectorSyncResult.  # noqa: E501
        :type: list[str]
        """

        self._log_lines = log_lines

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ConnectorSyncResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ConnectorSyncResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/connector_sync_request_result_exception_cause_stack_trace.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ConnectorSyncRequestResultExceptionCauseStackTrace(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'class_loader_name': 'str',
        'module_name': 'str',
        'module_version': 'str',
        'method_name': 'str',
        'file_name': 'str',
        'line_number': 'int',
        'class_name': 'str',
        'native_method': 'bool'
    }

    attribute_map = {
        'class_loader_name': 'classLoaderName',
        'module_name': 'moduleName',
        'module_version': 'moduleVersion',
        'method_name': 'methodName',
        'file_name': 'fileName',
        'line_number': 'lineNumber',
        'class_name': 'className',
        'native_method': 'nativeMethod'
    }

    def __init__(self, class_loader_name=None, module_name=None, module_version=None, method_name=None, file_name=None, line_number=None, class_name=None, native_method=None, local_vars_configuration=None):  # noqa: E501
        """ConnectorSyncRequestResultExceptionCauseStackTrace - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._class_loader_name = None
        self._module_name = None
        self._module_version = None
        self._method_name = None
        self._file_name = None
        self._line_number = None
        self._class_name = None
        self._native_method = None
        self.discriminator = None

        if class_loader_name is not None:
            self.class_loader_name = class_loader_name
        if module_name is not None:
            self.module_name = module_name
        if module_version is not None:
            self.module_version = module_version
        if method_name is not None:
            self.method_name = method_name
        if file_name is not None:
            self.file_name = file_name
        if line_number is not None:
            self.line_number = line_number
        if class_name is not None:
            self.class_name = class_name
        if native_method is not None:
            self.native_method = native_method

    @property
    def class_loader_name(self):
        """Gets the class_loader_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501


        :return: The class_loader_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501
        :rtype: str
        """
        return self._class_loader_name

    @class_loader_name.setter
    def class_loader_name(self, class_loader_name):
        """Sets the class_loader_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.


        :param class_loader_name: The class_loader_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501
        :type: str
        """

        self._class_loader_name = class_loader_name

    @property
    def module_name(self):
        """Gets the module_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501


        :return: The module_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501
        :rtype: str
        """
        return self._module_name

    @module_name.setter
    def module_name(self, module_name):
        """Sets the module_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.


        :param module_name: The module_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501
        :type: str
        """

        self._module_name = module_name

    @property
    def module_version(self):
        """Gets the module_version of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501


        :return: The module_version of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501
        :rtype: str
        """
        return self._module_version

    @module_version.setter
    def module_version(self, module_version):
        """Sets the module_version of this ConnectorSyncRequestResultExceptionCauseStackTrace.


        :param module_version: The module_version of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501
        :type: str
        """

        self._module_version = module_version

    @property
    def method_name(self):
        """Gets the method_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501


        :return: The method_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501
        :rtype: str
        """
        return self._method_name

    @method_name.setter
    def method_name(self, method_name):
        """Sets the method_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.


        :param method_name: The method_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501
        :type: str
        """

        self._method_name = method_name

    @property
    def file_name(self):
        """Gets the file_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501


        :return: The file_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501
        :rtype: str
        """
        return self._file_name

    @file_name.setter
    def file_name(self, file_name):
        """Sets the file_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.


        :param file_name: The file_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501
        :type: str
        """

        self._file_name = file_name

    @property
    def line_number(self):
        """Gets the line_number of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501


        :return: The line_number of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501
        :rtype: int
        """
        return self._line_number

    @line_number.setter
    def line_number(self, line_number):
        """Sets the line_number of this ConnectorSyncRequestResultExceptionCauseStackTrace.


        :param line_number: The line_number of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501
        :type: int
        """

        self._line_number = line_number

    @property
    def class_name(self):
        """Gets the class_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501


        :return: The class_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501
        :rtype: str
        """
        return self._class_name

    @class_name.setter
    def class_name(self, class_name):
        """Sets the class_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.


        :param class_name: The class_name of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501
        :type: str
        """

        self._class_name = class_name

    @property
    def native_method(self):
        """Gets the native_method of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501


        :return: The native_method of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501
        :rtype: bool
        """
        return self._native_method

    @native_method.setter
    def native_method(self, native_method):
        """Sets the native_method of this ConnectorSyncRequestResultExceptionCauseStackTrace.


        :param native_method: The native_method of this ConnectorSyncRequestResultExceptionCauseStackTrace.  # noqa: E501
        :type: bool
        """

        self._native_method = native_method

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ConnectorSyncRequestResultExceptionCauseStackTrace):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ConnectorSyncRequestResultExceptionCauseStackTrace):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/connector_sync_request_result_exception_cause.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ConnectorSyncRequestResultExceptionCause(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'stack_trace': 'list[ConnectorSyncRequestResultExceptionCauseStackTrace]',
        'message': 'str',
        'localized_message': 'str'
    }

    attribute_map = {
        'stack_trace': 'stackTrace',
        'message': 'message',
        'localized_message': 'localizedMessage'
    }

    def __init__(self, stack_trace=None, message=None, localized_message=None, local_vars_configuration=None):  # noqa: E501
        """ConnectorSyncRequestResultExceptionCause - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._stack_trace = None
        self._message = None
        self._localized_message = None
        self.discriminator = None

        if stack_trace is not None:
            self.stack_trace = stack_trace
        if message is not None:
            self.message = message
        if localized_message is not None:
            self.localized_message = localized_message

    @property
    def stack_trace(self):
        """Gets the stack_trace of this ConnectorSyncRequestResultExceptionCause.  # noqa: E501


        :return: The stack_trace of this ConnectorSyncRequestResultExceptionCause.  # noqa: E501
        :rtype: list[ConnectorSyncRequestResultExceptionCauseStackTrace]
        """
        return self._stack_trace

    @stack_trace.setter
    def stack_trace(self, stack_trace):
        """Sets the stack_trace of this ConnectorSyncRequestResultExceptionCause.


        :param stack_trace: The stack_trace of this ConnectorSyncRequestResultExceptionCause.  # noqa: E501
        :type: list[ConnectorSyncRequestResultExceptionCauseStackTrace]
        """

        self._stack_trace = stack_trace

    @property
    def message(self):
        """Gets the message of this ConnectorSyncRequestResultExceptionCause.  # noqa: E501


        :return: The message of this ConnectorSyncRequestResultExceptionCause.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this ConnectorSyncRequestResultExceptionCause.


        :param message: The message of this ConnectorSyncRequestResultExceptionCause.  # noqa: E501
        :type: str
        """

        self._message = message

    @property
    def localized_message(self):
        """Gets the localized_message of this ConnectorSyncRequestResultExceptionCause.  # noqa: E501


        :return: The localized_message of this ConnectorSyncRequestResultExceptionCause.  # noqa: E501
        :rtype: str
        """
        return self._localized_message

    @localized_message.setter
    def localized_message(self, localized_message):
        """Sets the localized_message of this ConnectorSyncRequestResultExceptionCause.


        :param localized_message: The localized_message of this ConnectorSyncRequestResultExceptionCause.  # noqa: E501
        :type: str
        """

        self._localized_message = localized_message

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ConnectorSyncRequestResultExceptionCause):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ConnectorSyncRequestResultExceptionCause):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/connector_sync_request_result_exception.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ConnectorSyncRequestResultException(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'cause': 'ConnectorSyncRequestResultExceptionCause',
        'stack_trace': 'list[ConnectorSyncRequestResultExceptionCauseStackTrace]',
        'message': 'str',
        'suppressed': 'list[ConnectorSyncRequestResultExceptionCause]',
        'localized_message': 'str'
    }

    attribute_map = {
        'cause': 'cause',
        'stack_trace': 'stackTrace',
        'message': 'message',
        'suppressed': 'suppressed',
        'localized_message': 'localizedMessage'
    }

    def __init__(self, cause=None, stack_trace=None, message=None, suppressed=None, localized_message=None, local_vars_configuration=None):  # noqa: E501
        """ConnectorSyncRequestResultException - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._cause = None
        self._stack_trace = None
        self._message = None
        self._suppressed = None
        self._localized_message = None
        self.discriminator = None

        if cause is not None:
            self.cause = cause
        if stack_trace is not None:
            self.stack_trace = stack_trace
        if message is not None:
            self.message = message
        if suppressed is not None:
            self.suppressed = suppressed
        if localized_message is not None:
            self.localized_message = localized_message

    @property
    def cause(self):
        """Gets the cause of this ConnectorSyncRequestResultException.  # noqa: E501


        :return: The cause of this ConnectorSyncRequestResultException.  # noqa: E501
        :rtype: ConnectorSyncRequestResultExceptionCause
        """
        return self._cause

    @cause.setter
    def cause(self, cause):
        """Sets the cause of this ConnectorSyncRequestResultException.


        :param cause: The cause of this ConnectorSyncRequestResultException.  # noqa: E501
        :type: ConnectorSyncRequestResultExceptionCause
        """

        self._cause = cause

    @property
    def stack_trace(self):
        """Gets the stack_trace of this ConnectorSyncRequestResultException.  # noqa: E501


        :return: The stack_trace of this ConnectorSyncRequestResultException.  # noqa: E501
        :rtype: list[ConnectorSyncRequestResultExceptionCauseStackTrace]
        """
        return self._stack_trace

    @stack_trace.setter
    def stack_trace(self, stack_trace):
        """Sets the stack_trace of this ConnectorSyncRequestResultException.


        :param stack_trace: The stack_trace of this ConnectorSyncRequestResultException.  # noqa: E501
        :type: list[ConnectorSyncRequestResultExceptionCauseStackTrace]
        """

        self._stack_trace = stack_trace

    @property
    def message(self):
        """Gets the message of this ConnectorSyncRequestResultException.  # noqa: E501


        :return: The message of this ConnectorSyncRequestResultException.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this ConnectorSyncRequestResultException.


        :param message: The message of this ConnectorSyncRequestResultException.  # noqa: E501
        :type: str
        """

        self._message = message

    @property
    def suppressed(self):
        """Gets the suppressed of this ConnectorSyncRequestResultException.  # noqa: E501


        :return: The suppressed of this ConnectorSyncRequestResultException.  # noqa: E501
        :rtype: list[ConnectorSyncRequestResultExceptionCause]
        """
        return self._suppressed

    @suppressed.setter
    def suppressed(self, suppressed):
        """Sets the suppressed of this ConnectorSyncRequestResultException.


        :param suppressed: The suppressed of this ConnectorSyncRequestResultException.  # noqa: E501
        :type: list[ConnectorSyncRequestResultExceptionCause]
        """

        self._suppressed = suppressed

    @property
    def localized_message(self):
        """Gets the localized_message of this ConnectorSyncRequestResultException.  # noqa: E501


        :return: The localized_message of this ConnectorSyncRequestResultException.  # noqa: E501
        :rtype: str
        """
        return self._localized_message

    @localized_message.setter
    def localized_message(self, localized_message):
        """Sets the localized_message of this ConnectorSyncRequestResultException.


        :param localized_message: The localized_message of this ConnectorSyncRequestResultException.  # noqa: E501
        :type: str
        """

        self._localized_message = localized_message

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ConnectorSyncRequestResultException):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ConnectorSyncRequestResultException):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/connector_sync_request_result.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ConnectorSyncRequestResult(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'sync_result': 'ConnectorSyncResult',
        'exception': 'ConnectorSyncRequestResultException',
        'event_id': 'str'
    }

    attribute_map = {
        'sync_result': 'syncResult',
        'exception': 'exception',
        'event_id': 'eventId'
    }

    def __init__(self, sync_result=None, exception=None, event_id=None, local_vars_configuration=None):  # noqa: E501
        """ConnectorSyncRequestResult - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._sync_result = None
        self._exception = None
        self._event_id = None
        self.discriminator = None

        if sync_result is not None:
            self.sync_result = sync_result
        if exception is not None:
            self.exception = exception
        if event_id is not None:
            self.event_id = event_id

    @property
    def sync_result(self):
        """Gets the sync_result of this ConnectorSyncRequestResult.  # noqa: E501


        :return: The sync_result of this ConnectorSyncRequestResult.  # noqa: E501
        :rtype: ConnectorSyncResult
        """
        return self._sync_result

    @sync_result.setter
    def sync_result(self, sync_result):
        """Sets the sync_result of this ConnectorSyncRequestResult.


        :param sync_result: The sync_result of this ConnectorSyncRequestResult.  # noqa: E501
        :type: ConnectorSyncResult
        """

        self._sync_result = sync_result

    @property
    def exception(self):
        """Gets the exception of this ConnectorSyncRequestResult.  # noqa: E501


        :return: The exception of this ConnectorSyncRequestResult.  # noqa: E501
        :rtype: ConnectorSyncRequestResultException
        """
        return self._exception

    @exception.setter
    def exception(self, exception):
        """Sets the exception of this ConnectorSyncRequestResult.


        :param exception: The exception of this ConnectorSyncRequestResult.  # noqa: E501
        :type: ConnectorSyncRequestResultException
        """

        self._exception = exception

    @property
    def event_id(self):
        """Gets the event_id of this ConnectorSyncRequestResult.  # noqa: E501


        :return: The event_id of this ConnectorSyncRequestResult.  # noqa: E501
        :rtype: str
        """
        return self._event_id

    @event_id.setter
    def event_id(self, event_id):
        """Sets the event_id of this ConnectorSyncRequestResult.


        :param event_id: The event_id of this ConnectorSyncRequestResult.  # noqa: E501
        :type: str
        """

        self._event_id = event_id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ConnectorSyncRequestResult):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ConnectorSyncRequestResult):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/connector_sync_event_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ConnectorSyncEventProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'connector_id': 'str',
        'sync_count': 'int',
        'sync_status': 'str',
        'message': 'str',
        'id': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'connector_id': 'connectorId',
        'sync_count': 'syncCount',
        'sync_status': 'syncStatus',
        'message': 'message',
        'id': 'id'
    }

    def __init__(self, created_at=None, connector_id=None, sync_count=None, sync_status=None, message=None, id=None, local_vars_configuration=None):  # noqa: E501
        """ConnectorSyncEventProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._connector_id = None
        self._sync_count = None
        self._sync_status = None
        self._message = None
        self._id = None
        self.discriminator = None

        self.created_at = created_at
        self.connector_id = connector_id
        self.sync_count = sync_count
        self.sync_status = sync_status
        if message is not None:
            self.message = message
        if id is not None:
            self.id = id

    @property
    def created_at(self):
        """Gets the created_at of this ConnectorSyncEventProjection.  # noqa: E501


        :return: The created_at of this ConnectorSyncEventProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this ConnectorSyncEventProjection.


        :param created_at: The created_at of this ConnectorSyncEventProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def connector_id(self):
        """Gets the connector_id of this ConnectorSyncEventProjection.  # noqa: E501


        :return: The connector_id of this ConnectorSyncEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._connector_id

    @connector_id.setter
    def connector_id(self, connector_id):
        """Sets the connector_id of this ConnectorSyncEventProjection.


        :param connector_id: The connector_id of this ConnectorSyncEventProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and connector_id is None:  # noqa: E501
            raise ValueError("Invalid value for `connector_id`, must not be `None`")  # noqa: E501

        self._connector_id = connector_id

    @property
    def sync_count(self):
        """Gets the sync_count of this ConnectorSyncEventProjection.  # noqa: E501


        :return: The sync_count of this ConnectorSyncEventProjection.  # noqa: E501
        :rtype: int
        """
        return self._sync_count

    @sync_count.setter
    def sync_count(self, sync_count):
        """Sets the sync_count of this ConnectorSyncEventProjection.


        :param sync_count: The sync_count of this ConnectorSyncEventProjection.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and sync_count is None:  # noqa: E501
            raise ValueError("Invalid value for `sync_count`, must not be `None`")  # noqa: E501

        self._sync_count = sync_count

    @property
    def sync_status(self):
        """Gets the sync_status of this ConnectorSyncEventProjection.  # noqa: E501


        :return: The sync_status of this ConnectorSyncEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._sync_status

    @sync_status.setter
    def sync_status(self, sync_status):
        """Sets the sync_status of this ConnectorSyncEventProjection.


        :param sync_status: The sync_status of this ConnectorSyncEventProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and sync_status is None:  # noqa: E501
            raise ValueError("Invalid value for `sync_status`, must not be `None`")  # noqa: E501
        allowed_values = ["SUCCESS", "INTERNAL_ERROR", "SUBSCRIPTION_ERROR", "CONNECTION_ERROR", "NOT_FOUND"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and sync_status not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `sync_status` ({0}), must be one of {1}"  # noqa: E501
                .format(sync_status, allowed_values)
            )

        self._sync_status = sync_status

    @property
    def message(self):
        """Gets the message of this ConnectorSyncEventProjection.  # noqa: E501


        :return: The message of this ConnectorSyncEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this ConnectorSyncEventProjection.


        :param message: The message of this ConnectorSyncEventProjection.  # noqa: E501
        :type: str
        """

        self._message = message

    @property
    def id(self):
        """Gets the id of this ConnectorSyncEventProjection.  # noqa: E501


        :return: The id of this ConnectorSyncEventProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this ConnectorSyncEventProjection.


        :param id: The id of this ConnectorSyncEventProjection.  # noqa: E501
        :type: str
        """

        self._id = id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ConnectorSyncEventProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ConnectorSyncEventProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/connector_sync_event_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ConnectorSyncEventDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'connector_id': 'str',
        'sync_status': 'str',
        'sync_count': 'int',
        'message': 'str',
        'created_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'connector_id': 'connectorId',
        'sync_status': 'syncStatus',
        'sync_count': 'syncCount',
        'message': 'message',
        'created_at': 'createdAt'
    }

    def __init__(self, id=None, connector_id=None, sync_status=None, sync_count=None, message=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """ConnectorSyncEventDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._connector_id = None
        self._sync_status = None
        self._sync_count = None
        self._message = None
        self._created_at = None
        self.discriminator = None

        self.id = id
        self.connector_id = connector_id
        self.sync_status = sync_status
        self.sync_count = sync_count
        if message is not None:
            self.message = message
        self.created_at = created_at

    @property
    def id(self):
        """Gets the id of this ConnectorSyncEventDto.  # noqa: E501


        :return: The id of this ConnectorSyncEventDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this ConnectorSyncEventDto.


        :param id: The id of this ConnectorSyncEventDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def connector_id(self):
        """Gets the connector_id of this ConnectorSyncEventDto.  # noqa: E501


        :return: The connector_id of this ConnectorSyncEventDto.  # noqa: E501
        :rtype: str
        """
        return self._connector_id

    @connector_id.setter
    def connector_id(self, connector_id):
        """Sets the connector_id of this ConnectorSyncEventDto.


        :param connector_id: The connector_id of this ConnectorSyncEventDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and connector_id is None:  # noqa: E501
            raise ValueError("Invalid value for `connector_id`, must not be `None`")  # noqa: E501

        self._connector_id = connector_id

    @property
    def sync_status(self):
        """Gets the sync_status of this ConnectorSyncEventDto.  # noqa: E501


        :return: The sync_status of this ConnectorSyncEventDto.  # noqa: E501
        :rtype: str
        """
        return self._sync_status

    @sync_status.setter
    def sync_status(self, sync_status):
        """Sets the sync_status of this ConnectorSyncEventDto.


        :param sync_status: The sync_status of this ConnectorSyncEventDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and sync_status is None:  # noqa: E501
            raise ValueError("Invalid value for `sync_status`, must not be `None`")  # noqa: E501
        allowed_values = ["SUCCESS", "INTERNAL_ERROR", "SUBSCRIPTION_ERROR", "CONNECTION_ERROR", "NOT_FOUND"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and sync_status not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `sync_status` ({0}), must be one of {1}"  # noqa: E501
                .format(sync_status, allowed_values)
            )

        self._sync_status = sync_status

    @property
    def sync_count(self):
        """Gets the sync_count of this ConnectorSyncEventDto.  # noqa: E501


        :return: The sync_count of this ConnectorSyncEventDto.  # noqa: E501
        :rtype: int
        """
        return self._sync_count

    @sync_count.setter
    def sync_count(self, sync_count):
        """Sets the sync_count of this ConnectorSyncEventDto.


        :param sync_count: The sync_count of this ConnectorSyncEventDto.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and sync_count is None:  # noqa: E501
            raise ValueError("Invalid value for `sync_count`, must not be `None`")  # noqa: E501

        self._sync_count = sync_count

    @property
    def message(self):
        """Gets the message of this ConnectorSyncEventDto.  # noqa: E501


        :return: The message of this ConnectorSyncEventDto.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this ConnectorSyncEventDto.


        :param message: The message of this ConnectorSyncEventDto.  # noqa: E501
        :type: str
        """

        self._message = message

    @property
    def created_at(self):
        """Gets the created_at of this ConnectorSyncEventDto.  # noqa: E501


        :return: The created_at of this ConnectorSyncEventDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this ConnectorSyncEventDto.


        :param created_at: The created_at of this ConnectorSyncEventDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ConnectorSyncEventDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ConnectorSyncEventDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/connector_smtp_connection_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ConnectorSmtpConnectionDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'connector_id': 'str',
        'smtp_host': 'str',
        'smtp_port': 'int',
        'smtp_username': 'str',
        'smtp_password': 'str',
        'smtp_ssl': 'bool',
        'enabled': 'bool',
        'created_at': 'datetime',
        'id': 'str'
    }

    attribute_map = {
        'connector_id': 'connectorId',
        'smtp_host': 'smtpHost',
        'smtp_port': 'smtpPort',
        'smtp_username': 'smtpUsername',
        'smtp_password': 'smtpPassword',
        'smtp_ssl': 'smtpSsl',
        'enabled': 'enabled',
        'created_at': 'createdAt',
        'id': 'id'
    }

    def __init__(self, connector_id=None, smtp_host=None, smtp_port=None, smtp_username=None, smtp_password=None, smtp_ssl=None, enabled=None, created_at=None, id=None, local_vars_configuration=None):  # noqa: E501
        """ConnectorSmtpConnectionDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._connector_id = None
        self._smtp_host = None
        self._smtp_port = None
        self._smtp_username = None
        self._smtp_password = None
        self._smtp_ssl = None
        self._enabled = None
        self._created_at = None
        self._id = None
        self.discriminator = None

        self.connector_id = connector_id
        if smtp_host is not None:
            self.smtp_host = smtp_host
        if smtp_port is not None:
            self.smtp_port = smtp_port
        if smtp_username is not None:
            self.smtp_username = smtp_username
        if smtp_password is not None:
            self.smtp_password = smtp_password
        if smtp_ssl is not None:
            self.smtp_ssl = smtp_ssl
        if enabled is not None:
            self.enabled = enabled
        self.created_at = created_at
        self.id = id

    @property
    def connector_id(self):
        """Gets the connector_id of this ConnectorSmtpConnectionDto.  # noqa: E501


        :return: The connector_id of this ConnectorSmtpConnectionDto.  # noqa: E501
        :rtype: str
        """
        return self._connector_id

    @connector_id.setter
    def connector_id(self, connector_id):
        """Sets the connector_id of this ConnectorSmtpConnectionDto.


        :param connector_id: The connector_id of this ConnectorSmtpConnectionDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and connector_id is None:  # noqa: E501
            raise ValueError("Invalid value for `connector_id`, must not be `None`")  # noqa: E501

        self._connector_id = connector_id

    @property
    def smtp_host(self):
        """Gets the smtp_host of this ConnectorSmtpConnectionDto.  # noqa: E501


        :return: The smtp_host of this ConnectorSmtpConnectionDto.  # noqa: E501
        :rtype: str
        """
        return self._smtp_host

    @smtp_host.setter
    def smtp_host(self, smtp_host):
        """Sets the smtp_host of this ConnectorSmtpConnectionDto.


        :param smtp_host: The smtp_host of this ConnectorSmtpConnectionDto.  # noqa: E501
        :type: str
        """

        self._smtp_host = smtp_host

    @property
    def smtp_port(self):
        """Gets the smtp_port of this ConnectorSmtpConnectionDto.  # noqa: E501


        :return: The smtp_port of this ConnectorSmtpConnectionDto.  # noqa: E501
        :rtype: int
        """
        return self._smtp_port

    @smtp_port.setter
    def smtp_port(self, smtp_port):
        """Sets the smtp_port of this ConnectorSmtpConnectionDto.


        :param smtp_port: The smtp_port of this ConnectorSmtpConnectionDto.  # noqa: E501
        :type: int
        """

        self._smtp_port = smtp_port

    @property
    def smtp_username(self):
        """Gets the smtp_username of this ConnectorSmtpConnectionDto.  # noqa: E501


        :return: The smtp_username of this ConnectorSmtpConnectionDto.  # noqa: E501
        :rtype: str
        """
        return self._smtp_username

    @smtp_username.setter
    def smtp_username(self, smtp_username):
        """Sets the smtp_username of this ConnectorSmtpConnectionDto.


        :param smtp_username: The smtp_username of this ConnectorSmtpConnectionDto.  # noqa: E501
        :type: str
        """

        self._smtp_username = smtp_username

    @property
    def smtp_password(self):
        """Gets the smtp_password of this ConnectorSmtpConnectionDto.  # noqa: E501


        :return: The smtp_password of this ConnectorSmtpConnectionDto.  # noqa: E501
        :rtype: str
        """
        return self._smtp_password

    @smtp_password.setter
    def smtp_password(self, smtp_password):
        """Sets the smtp_password of this ConnectorSmtpConnectionDto.


        :param smtp_password: The smtp_password of this ConnectorSmtpConnectionDto.  # noqa: E501
        :type: str
        """

        self._smtp_password = smtp_password

    @property
    def smtp_ssl(self):
        """Gets the smtp_ssl of this ConnectorSmtpConnectionDto.  # noqa: E501


        :return: The smtp_ssl of this ConnectorSmtpConnectionDto.  # noqa: E501
        :rtype: bool
        """
        return self._smtp_ssl

    @smtp_ssl.setter
    def smtp_ssl(self, smtp_ssl):
        """Sets the smtp_ssl of this ConnectorSmtpConnectionDto.


        :param smtp_ssl: The smtp_ssl of this ConnectorSmtpConnectionDto.  # noqa: E501
        :type: bool
        """

        self._smtp_ssl = smtp_ssl

    @property
    def enabled(self):
        """Gets the enabled of this ConnectorSmtpConnectionDto.  # noqa: E501


        :return: The enabled of this ConnectorSmtpConnectionDto.  # noqa: E501
        :rtype: bool
        """
        return self._enabled

    @enabled.setter
    def enabled(self, enabled):
        """Sets the enabled of this ConnectorSmtpConnectionDto.


        :param enabled: The enabled of this ConnectorSmtpConnectionDto.  # noqa: E501
        :type: bool
        """

        self._enabled = enabled

    @property
    def created_at(self):
        """Gets the created_at of this ConnectorSmtpConnectionDto.  # noqa: E501


        :return: The created_at of this ConnectorSmtpConnectionDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this ConnectorSmtpConnectionDto.


        :param created_at: The created_at of this ConnectorSmtpConnectionDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def id(self):
        """Gets the id of this ConnectorSmtpConnectionDto.  # noqa: E501


        :return: The id of this ConnectorSmtpConnectionDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this ConnectorSmtpConnectionDto.


        :param id: The id of this ConnectorSmtpConnectionDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ConnectorSmtpConnectionDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ConnectorSmtpConnectionDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/connector_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ConnectorProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'enabled': 'bool',
        'inbox_id': 'str',
        'email_address': 'str',
        'user_id': 'str',
        'sync_enabled': 'bool',
        'sync_schedule_type': 'str',
        'sync_interval': 'int',
        'name': 'str',
        'id': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'enabled': 'enabled',
        'inbox_id': 'inboxId',
        'email_address': 'emailAddress',
        'user_id': 'userId',
        'sync_enabled': 'syncEnabled',
        'sync_schedule_type': 'syncScheduleType',
        'sync_interval': 'syncInterval',
        'name': 'name',
        'id': 'id'
    }

    def __init__(self, created_at=None, enabled=None, inbox_id=None, email_address=None, user_id=None, sync_enabled=None, sync_schedule_type=None, sync_interval=None, name=None, id=None, local_vars_configuration=None):  # noqa: E501
        """ConnectorProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._enabled = None
        self._inbox_id = None
        self._email_address = None
        self._user_id = None
        self._sync_enabled = None
        self._sync_schedule_type = None
        self._sync_interval = None
        self._name = None
        self._id = None
        self.discriminator = None

        self.created_at = created_at
        if enabled is not None:
            self.enabled = enabled
        self.inbox_id = inbox_id
        if email_address is not None:
            self.email_address = email_address
        self.user_id = user_id
        if sync_enabled is not None:
            self.sync_enabled = sync_enabled
        self.sync_schedule_type = sync_schedule_type
        if sync_interval is not None:
            self.sync_interval = sync_interval
        if name is not None:
            self.name = name
        if id is not None:
            self.id = id

    @property
    def created_at(self):
        """Gets the created_at of this ConnectorProjection.  # noqa: E501


        :return: The created_at of this ConnectorProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this ConnectorProjection.


        :param created_at: The created_at of this ConnectorProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def enabled(self):
        """Gets the enabled of this ConnectorProjection.  # noqa: E501


        :return: The enabled of this ConnectorProjection.  # noqa: E501
        :rtype: bool
        """
        return self._enabled

    @enabled.setter
    def enabled(self, enabled):
        """Sets the enabled of this ConnectorProjection.


        :param enabled: The enabled of this ConnectorProjection.  # noqa: E501
        :type: bool
        """

        self._enabled = enabled

    @property
    def inbox_id(self):
        """Gets the inbox_id of this ConnectorProjection.  # noqa: E501


        :return: The inbox_id of this ConnectorProjection.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this ConnectorProjection.


        :param inbox_id: The inbox_id of this ConnectorProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def email_address(self):
        """Gets the email_address of this ConnectorProjection.  # noqa: E501


        :return: The email_address of this ConnectorProjection.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this ConnectorProjection.


        :param email_address: The email_address of this ConnectorProjection.  # noqa: E501
        :type: str
        """

        self._email_address = email_address

    @property
    def user_id(self):
        """Gets the user_id of this ConnectorProjection.  # noqa: E501


        :return: The user_id of this ConnectorProjection.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this ConnectorProjection.


        :param user_id: The user_id of this ConnectorProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def sync_enabled(self):
        """Gets the sync_enabled of this ConnectorProjection.  # noqa: E501


        :return: The sync_enabled of this ConnectorProjection.  # noqa: E501
        :rtype: bool
        """
        return self._sync_enabled

    @sync_enabled.setter
    def sync_enabled(self, sync_enabled):
        """Sets the sync_enabled of this ConnectorProjection.


        :param sync_enabled: The sync_enabled of this ConnectorProjection.  # noqa: E501
        :type: bool
        """

        self._sync_enabled = sync_enabled

    @property
    def sync_schedule_type(self):
        """Gets the sync_schedule_type of this ConnectorProjection.  # noqa: E501


        :return: The sync_schedule_type of this ConnectorProjection.  # noqa: E501
        :rtype: str
        """
        return self._sync_schedule_type

    @sync_schedule_type.setter
    def sync_schedule_type(self, sync_schedule_type):
        """Sets the sync_schedule_type of this ConnectorProjection.


        :param sync_schedule_type: The sync_schedule_type of this ConnectorProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and sync_schedule_type is None:  # noqa: E501
            raise ValueError("Invalid value for `sync_schedule_type`, must not be `None`")  # noqa: E501
        allowed_values = ["INTERVAL"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and sync_schedule_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `sync_schedule_type` ({0}), must be one of {1}"  # noqa: E501
                .format(sync_schedule_type, allowed_values)
            )

        self._sync_schedule_type = sync_schedule_type

    @property
    def sync_interval(self):
        """Gets the sync_interval of this ConnectorProjection.  # noqa: E501


        :return: The sync_interval of this ConnectorProjection.  # noqa: E501
        :rtype: int
        """
        return self._sync_interval

    @sync_interval.setter
    def sync_interval(self, sync_interval):
        """Sets the sync_interval of this ConnectorProjection.


        :param sync_interval: The sync_interval of this ConnectorProjection.  # noqa: E501
        :type: int
        """

        self._sync_interval = sync_interval

    @property
    def name(self):
        """Gets the name of this ConnectorProjection.  # noqa: E501


        :return: The name of this ConnectorProjection.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this ConnectorProjection.


        :param name: The name of this ConnectorProjection.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def id(self):
        """Gets the id of this ConnectorProjection.  # noqa: E501


        :return: The id of this ConnectorProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this ConnectorProjection.


        :param id: The id of this ConnectorProjection.  # noqa: E501
        :type: str
        """

        self._id = id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ConnectorProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ConnectorProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/connector_imap_connection_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ConnectorImapConnectionDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'connector_id': 'str',
        'imap_host': 'str',
        'imap_port': 'int',
        'imap_username': 'str',
        'imap_password': 'str',
        'imap_ssl': 'bool',
        'select_folder': 'str',
        'search_terms': 'str',
        'enabled': 'bool',
        'created_at': 'datetime',
        'id': 'str'
    }

    attribute_map = {
        'connector_id': 'connectorId',
        'imap_host': 'imapHost',
        'imap_port': 'imapPort',
        'imap_username': 'imapUsername',
        'imap_password': 'imapPassword',
        'imap_ssl': 'imapSsl',
        'select_folder': 'selectFolder',
        'search_terms': 'searchTerms',
        'enabled': 'enabled',
        'created_at': 'createdAt',
        'id': 'id'
    }

    def __init__(self, connector_id=None, imap_host=None, imap_port=None, imap_username=None, imap_password=None, imap_ssl=None, select_folder=None, search_terms=None, enabled=None, created_at=None, id=None, local_vars_configuration=None):  # noqa: E501
        """ConnectorImapConnectionDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._connector_id = None
        self._imap_host = None
        self._imap_port = None
        self._imap_username = None
        self._imap_password = None
        self._imap_ssl = None
        self._select_folder = None
        self._search_terms = None
        self._enabled = None
        self._created_at = None
        self._id = None
        self.discriminator = None

        self.connector_id = connector_id
        if imap_host is not None:
            self.imap_host = imap_host
        if imap_port is not None:
            self.imap_port = imap_port
        if imap_username is not None:
            self.imap_username = imap_username
        if imap_password is not None:
            self.imap_password = imap_password
        if imap_ssl is not None:
            self.imap_ssl = imap_ssl
        if select_folder is not None:
            self.select_folder = select_folder
        if search_terms is not None:
            self.search_terms = search_terms
        if enabled is not None:
            self.enabled = enabled
        self.created_at = created_at
        self.id = id

    @property
    def connector_id(self):
        """Gets the connector_id of this ConnectorImapConnectionDto.  # noqa: E501


        :return: The connector_id of this ConnectorImapConnectionDto.  # noqa: E501
        :rtype: str
        """
        return self._connector_id

    @connector_id.setter
    def connector_id(self, connector_id):
        """Sets the connector_id of this ConnectorImapConnectionDto.


        :param connector_id: The connector_id of this ConnectorImapConnectionDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and connector_id is None:  # noqa: E501
            raise ValueError("Invalid value for `connector_id`, must not be `None`")  # noqa: E501

        self._connector_id = connector_id

    @property
    def imap_host(self):
        """Gets the imap_host of this ConnectorImapConnectionDto.  # noqa: E501


        :return: The imap_host of this ConnectorImapConnectionDto.  # noqa: E501
        :rtype: str
        """
        return self._imap_host

    @imap_host.setter
    def imap_host(self, imap_host):
        """Sets the imap_host of this ConnectorImapConnectionDto.


        :param imap_host: The imap_host of this ConnectorImapConnectionDto.  # noqa: E501
        :type: str
        """

        self._imap_host = imap_host

    @property
    def imap_port(self):
        """Gets the imap_port of this ConnectorImapConnectionDto.  # noqa: E501


        :return: The imap_port of this ConnectorImapConnectionDto.  # noqa: E501
        :rtype: int
        """
        return self._imap_port

    @imap_port.setter
    def imap_port(self, imap_port):
        """Sets the imap_port of this ConnectorImapConnectionDto.


        :param imap_port: The imap_port of this ConnectorImapConnectionDto.  # noqa: E501
        :type: int
        """

        self._imap_port = imap_port

    @property
    def imap_username(self):
        """Gets the imap_username of this ConnectorImapConnectionDto.  # noqa: E501


        :return: The imap_username of this ConnectorImapConnectionDto.  # noqa: E501
        :rtype: str
        """
        return self._imap_username

    @imap_username.setter
    def imap_username(self, imap_username):
        """Sets the imap_username of this ConnectorImapConnectionDto.


        :param imap_username: The imap_username of this ConnectorImapConnectionDto.  # noqa: E501
        :type: str
        """

        self._imap_username = imap_username

    @property
    def imap_password(self):
        """Gets the imap_password of this ConnectorImapConnectionDto.  # noqa: E501


        :return: The imap_password of this ConnectorImapConnectionDto.  # noqa: E501
        :rtype: str
        """
        return self._imap_password

    @imap_password.setter
    def imap_password(self, imap_password):
        """Sets the imap_password of this ConnectorImapConnectionDto.


        :param imap_password: The imap_password of this ConnectorImapConnectionDto.  # noqa: E501
        :type: str
        """

        self._imap_password = imap_password

    @property
    def imap_ssl(self):
        """Gets the imap_ssl of this ConnectorImapConnectionDto.  # noqa: E501


        :return: The imap_ssl of this ConnectorImapConnectionDto.  # noqa: E501
        :rtype: bool
        """
        return self._imap_ssl

    @imap_ssl.setter
    def imap_ssl(self, imap_ssl):
        """Sets the imap_ssl of this ConnectorImapConnectionDto.


        :param imap_ssl: The imap_ssl of this ConnectorImapConnectionDto.  # noqa: E501
        :type: bool
        """

        self._imap_ssl = imap_ssl

    @property
    def select_folder(self):
        """Gets the select_folder of this ConnectorImapConnectionDto.  # noqa: E501


        :return: The select_folder of this ConnectorImapConnectionDto.  # noqa: E501
        :rtype: str
        """
        return self._select_folder

    @select_folder.setter
    def select_folder(self, select_folder):
        """Sets the select_folder of this ConnectorImapConnectionDto.


        :param select_folder: The select_folder of this ConnectorImapConnectionDto.  # noqa: E501
        :type: str
        """

        self._select_folder = select_folder

    @property
    def search_terms(self):
        """Gets the search_terms of this ConnectorImapConnectionDto.  # noqa: E501


        :return: The search_terms of this ConnectorImapConnectionDto.  # noqa: E501
        :rtype: str
        """
        return self._search_terms

    @search_terms.setter
    def search_terms(self, search_terms):
        """Sets the search_terms of this ConnectorImapConnectionDto.


        :param search_terms: The search_terms of this ConnectorImapConnectionDto.  # noqa: E501
        :type: str
        """

        self._search_terms = search_terms

    @property
    def enabled(self):
        """Gets the enabled of this ConnectorImapConnectionDto.  # noqa: E501


        :return: The enabled of this ConnectorImapConnectionDto.  # noqa: E501
        :rtype: bool
        """
        return self._enabled

    @enabled.setter
    def enabled(self, enabled):
        """Sets the enabled of this ConnectorImapConnectionDto.


        :param enabled: The enabled of this ConnectorImapConnectionDto.  # noqa: E501
        :type: bool
        """

        self._enabled = enabled

    @property
    def created_at(self):
        """Gets the created_at of this ConnectorImapConnectionDto.  # noqa: E501


        :return: The created_at of this ConnectorImapConnectionDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this ConnectorImapConnectionDto.


        :param created_at: The created_at of this ConnectorImapConnectionDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def id(self):
        """Gets the id of this ConnectorImapConnectionDto.  # noqa: E501


        :return: The id of this ConnectorImapConnectionDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this ConnectorImapConnectionDto.


        :param id: The id of this ConnectorImapConnectionDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ConnectorImapConnectionDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ConnectorImapConnectionDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/connector_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ConnectorDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'name': 'str',
        'enabled': 'bool',
        'user_id': 'str',
        'inbox_id': 'str',
        'sync_enabled': 'bool',
        'sync_schedule_type': 'str',
        'sync_interval': 'int',
        'has_imap_connection': 'bool',
        'has_smtp_connection': 'bool',
        'created_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'name': 'name',
        'enabled': 'enabled',
        'user_id': 'userId',
        'inbox_id': 'inboxId',
        'sync_enabled': 'syncEnabled',
        'sync_schedule_type': 'syncScheduleType',
        'sync_interval': 'syncInterval',
        'has_imap_connection': 'hasImapConnection',
        'has_smtp_connection': 'hasSmtpConnection',
        'created_at': 'createdAt'
    }

    def __init__(self, id=None, name=None, enabled=None, user_id=None, inbox_id=None, sync_enabled=None, sync_schedule_type=None, sync_interval=None, has_imap_connection=None, has_smtp_connection=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """ConnectorDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._name = None
        self._enabled = None
        self._user_id = None
        self._inbox_id = None
        self._sync_enabled = None
        self._sync_schedule_type = None
        self._sync_interval = None
        self._has_imap_connection = None
        self._has_smtp_connection = None
        self._created_at = None
        self.discriminator = None

        self.id = id
        self.name = name
        self.enabled = enabled
        self.user_id = user_id
        self.inbox_id = inbox_id
        self.sync_enabled = sync_enabled
        self.sync_schedule_type = sync_schedule_type
        self.sync_interval = sync_interval
        self.has_imap_connection = has_imap_connection
        self.has_smtp_connection = has_smtp_connection
        self.created_at = created_at

    @property
    def id(self):
        """Gets the id of this ConnectorDto.  # noqa: E501


        :return: The id of this ConnectorDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this ConnectorDto.


        :param id: The id of this ConnectorDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def name(self):
        """Gets the name of this ConnectorDto.  # noqa: E501


        :return: The name of this ConnectorDto.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this ConnectorDto.


        :param name: The name of this ConnectorDto.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def enabled(self):
        """Gets the enabled of this ConnectorDto.  # noqa: E501


        :return: The enabled of this ConnectorDto.  # noqa: E501
        :rtype: bool
        """
        return self._enabled

    @enabled.setter
    def enabled(self, enabled):
        """Sets the enabled of this ConnectorDto.


        :param enabled: The enabled of this ConnectorDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and enabled is None:  # noqa: E501
            raise ValueError("Invalid value for `enabled`, must not be `None`")  # noqa: E501

        self._enabled = enabled

    @property
    def user_id(self):
        """Gets the user_id of this ConnectorDto.  # noqa: E501


        :return: The user_id of this ConnectorDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this ConnectorDto.


        :param user_id: The user_id of this ConnectorDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def inbox_id(self):
        """Gets the inbox_id of this ConnectorDto.  # noqa: E501


        :return: The inbox_id of this ConnectorDto.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this ConnectorDto.


        :param inbox_id: The inbox_id of this ConnectorDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def sync_enabled(self):
        """Gets the sync_enabled of this ConnectorDto.  # noqa: E501


        :return: The sync_enabled of this ConnectorDto.  # noqa: E501
        :rtype: bool
        """
        return self._sync_enabled

    @sync_enabled.setter
    def sync_enabled(self, sync_enabled):
        """Sets the sync_enabled of this ConnectorDto.


        :param sync_enabled: The sync_enabled of this ConnectorDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and sync_enabled is None:  # noqa: E501
            raise ValueError("Invalid value for `sync_enabled`, must not be `None`")  # noqa: E501

        self._sync_enabled = sync_enabled

    @property
    def sync_schedule_type(self):
        """Gets the sync_schedule_type of this ConnectorDto.  # noqa: E501


        :return: The sync_schedule_type of this ConnectorDto.  # noqa: E501
        :rtype: str
        """
        return self._sync_schedule_type

    @sync_schedule_type.setter
    def sync_schedule_type(self, sync_schedule_type):
        """Sets the sync_schedule_type of this ConnectorDto.


        :param sync_schedule_type: The sync_schedule_type of this ConnectorDto.  # noqa: E501
        :type: str
        """
        allowed_values = [None,"INTERVAL"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and sync_schedule_type not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `sync_schedule_type` ({0}), must be one of {1}"  # noqa: E501
                .format(sync_schedule_type, allowed_values)
            )

        self._sync_schedule_type = sync_schedule_type

    @property
    def sync_interval(self):
        """Gets the sync_interval of this ConnectorDto.  # noqa: E501


        :return: The sync_interval of this ConnectorDto.  # noqa: E501
        :rtype: int
        """
        return self._sync_interval

    @sync_interval.setter
    def sync_interval(self, sync_interval):
        """Sets the sync_interval of this ConnectorDto.


        :param sync_interval: The sync_interval of this ConnectorDto.  # noqa: E501
        :type: int
        """

        self._sync_interval = sync_interval

    @property
    def has_imap_connection(self):
        """Gets the has_imap_connection of this ConnectorDto.  # noqa: E501


        :return: The has_imap_connection of this ConnectorDto.  # noqa: E501
        :rtype: bool
        """
        return self._has_imap_connection

    @has_imap_connection.setter
    def has_imap_connection(self, has_imap_connection):
        """Sets the has_imap_connection of this ConnectorDto.


        :param has_imap_connection: The has_imap_connection of this ConnectorDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and has_imap_connection is None:  # noqa: E501
            raise ValueError("Invalid value for `has_imap_connection`, must not be `None`")  # noqa: E501

        self._has_imap_connection = has_imap_connection

    @property
    def has_smtp_connection(self):
        """Gets the has_smtp_connection of this ConnectorDto.  # noqa: E501


        :return: The has_smtp_connection of this ConnectorDto.  # noqa: E501
        :rtype: bool
        """
        return self._has_smtp_connection

    @has_smtp_connection.setter
    def has_smtp_connection(self, has_smtp_connection):
        """Sets the has_smtp_connection of this ConnectorDto.


        :param has_smtp_connection: The has_smtp_connection of this ConnectorDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and has_smtp_connection is None:  # noqa: E501
            raise ValueError("Invalid value for `has_smtp_connection`, must not be `None`")  # noqa: E501

        self._has_smtp_connection = has_smtp_connection

    @property
    def created_at(self):
        """Gets the created_at of this ConnectorDto.  # noqa: E501


        :return: The created_at of this ConnectorDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this ConnectorDto.


        :param created_at: The created_at of this ConnectorDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ConnectorDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ConnectorDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/condition_option.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class ConditionOption(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'condition': 'str',
        'value': 'str'
    }

    attribute_map = {
        'condition': 'condition',
        'value': 'value'
    }

    def __init__(self, condition=None, value=None, local_vars_configuration=None):  # noqa: E501
        """ConditionOption - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._condition = None
        self._value = None
        self.discriminator = None

        self.condition = condition
        self.value = value

    @property
    def condition(self):
        """Gets the condition of this ConditionOption.  # noqa: E501

        Condition of an email object that can be used to filter results  # noqa: E501

        :return: The condition of this ConditionOption.  # noqa: E501
        :rtype: str
        """
        return self._condition

    @condition.setter
    def condition(self, condition):
        """Sets the condition of this ConditionOption.

        Condition of an email object that can be used to filter results  # noqa: E501

        :param condition: The condition of this ConditionOption.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and condition is None:  # noqa: E501
            raise ValueError("Invalid value for `condition`, must not be `None`")  # noqa: E501
        allowed_values = ["HAS_ATTACHMENTS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and condition not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `condition` ({0}), must be one of {1}"  # noqa: E501
                .format(condition, allowed_values)
            )

        self._condition = condition

    @property
    def value(self):
        """Gets the value of this ConditionOption.  # noqa: E501

        Expected condition value  # noqa: E501

        :return: The value of this ConditionOption.  # noqa: E501
        :rtype: str
        """
        return self._value

    @value.setter
    def value(self, value):
        """Sets the value of this ConditionOption.

        Expected condition value  # noqa: E501

        :param value: The value of this ConditionOption.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and value is None:  # noqa: E501
            raise ValueError("Invalid value for `value`, must not be `None`")  # noqa: E501
        allowed_values = ["TRUE", "FALSE"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and value not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `value` ({0}), must be one of {1}"  # noqa: E501
                .format(value, allowed_values)
            )

        self._value = value

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, ConditionOption):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, ConditionOption):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/complaint.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class Complaint(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'event_type': 'str',
        'mail_source': 'str',
        'mail_message_id': 'str',
        'complaint_recipient': 'str',
        'created_at': 'datetime',
        'updated_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'event_type': 'eventType',
        'mail_source': 'mailSource',
        'mail_message_id': 'mailMessageId',
        'complaint_recipient': 'complaintRecipient',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt'
    }

    def __init__(self, id=None, user_id=None, event_type=None, mail_source=None, mail_message_id=None, complaint_recipient=None, created_at=None, updated_at=None, local_vars_configuration=None):  # noqa: E501
        """Complaint - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._event_type = None
        self._mail_source = None
        self._mail_message_id = None
        self._complaint_recipient = None
        self._created_at = None
        self._updated_at = None
        self.discriminator = None

        self.id = id
        if user_id is not None:
            self.user_id = user_id
        if event_type is not None:
            self.event_type = event_type
        if mail_source is not None:
            self.mail_source = mail_source
        if mail_message_id is not None:
            self.mail_message_id = mail_message_id
        self.complaint_recipient = complaint_recipient
        self.created_at = created_at
        self.updated_at = updated_at

    @property
    def id(self):
        """Gets the id of this Complaint.  # noqa: E501


        :return: The id of this Complaint.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this Complaint.


        :param id: The id of this Complaint.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this Complaint.  # noqa: E501


        :return: The user_id of this Complaint.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this Complaint.


        :param user_id: The user_id of this Complaint.  # noqa: E501
        :type: str
        """

        self._user_id = user_id

    @property
    def event_type(self):
        """Gets the event_type of this Complaint.  # noqa: E501


        :return: The event_type of this Complaint.  # noqa: E501
        :rtype: str
        """
        return self._event_type

    @event_type.setter
    def event_type(self, event_type):
        """Sets the event_type of this Complaint.


        :param event_type: The event_type of this Complaint.  # noqa: E501
        :type: str
        """

        self._event_type = event_type

    @property
    def mail_source(self):
        """Gets the mail_source of this Complaint.  # noqa: E501


        :return: The mail_source of this Complaint.  # noqa: E501
        :rtype: str
        """
        return self._mail_source

    @mail_source.setter
    def mail_source(self, mail_source):
        """Sets the mail_source of this Complaint.


        :param mail_source: The mail_source of this Complaint.  # noqa: E501
        :type: str
        """

        self._mail_source = mail_source

    @property
    def mail_message_id(self):
        """Gets the mail_message_id of this Complaint.  # noqa: E501


        :return: The mail_message_id of this Complaint.  # noqa: E501
        :rtype: str
        """
        return self._mail_message_id

    @mail_message_id.setter
    def mail_message_id(self, mail_message_id):
        """Sets the mail_message_id of this Complaint.


        :param mail_message_id: The mail_message_id of this Complaint.  # noqa: E501
        :type: str
        """

        self._mail_message_id = mail_message_id

    @property
    def complaint_recipient(self):
        """Gets the complaint_recipient of this Complaint.  # noqa: E501


        :return: The complaint_recipient of this Complaint.  # noqa: E501
        :rtype: str
        """
        return self._complaint_recipient

    @complaint_recipient.setter
    def complaint_recipient(self, complaint_recipient):
        """Sets the complaint_recipient of this Complaint.


        :param complaint_recipient: The complaint_recipient of this Complaint.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and complaint_recipient is None:  # noqa: E501
            raise ValueError("Invalid value for `complaint_recipient`, must not be `None`")  # noqa: E501

        self._complaint_recipient = complaint_recipient

    @property
    def created_at(self):
        """Gets the created_at of this Complaint.  # noqa: E501


        :return: The created_at of this Complaint.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this Complaint.


        :param created_at: The created_at of this Complaint.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this Complaint.  # noqa: E501


        :return: The updated_at of this Complaint.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this Complaint.


        :param updated_at: The updated_at of this Complaint.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, Complaint):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, Complaint):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/check_email_features_client_support_results.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CheckEmailFeaturesClientSupportResults(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'result': 'EmailFeatureSupportResult'
    }

    attribute_map = {
        'result': 'result'
    }

    def __init__(self, result=None, local_vars_configuration=None):  # noqa: E501
        """CheckEmailFeaturesClientSupportResults - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._result = None
        self.discriminator = None

        self.result = result

    @property
    def result(self):
        """Gets the result of this CheckEmailFeaturesClientSupportResults.  # noqa: E501


        :return: The result of this CheckEmailFeaturesClientSupportResults.  # noqa: E501
        :rtype: EmailFeatureSupportResult
        """
        return self._result

    @result.setter
    def result(self, result):
        """Sets the result of this CheckEmailFeaturesClientSupportResults.


        :param result: The result of this CheckEmailFeaturesClientSupportResults.  # noqa: E501
        :type: EmailFeatureSupportResult
        """
        if self.local_vars_configuration.client_side_validation and result is None:  # noqa: E501
            raise ValueError("Invalid value for `result`, must not be `None`")  # noqa: E501

        self._result = result

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CheckEmailFeaturesClientSupportResults):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CheckEmailFeaturesClientSupportResults):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/check_email_features_client_support_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CheckEmailFeaturesClientSupportOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'email_body': 'str'
    }

    attribute_map = {
        'email_body': 'emailBody'
    }

    def __init__(self, email_body=None, local_vars_configuration=None):  # noqa: E501
        """CheckEmailFeaturesClientSupportOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._email_body = None
        self.discriminator = None

        self.email_body = email_body

    @property
    def email_body(self):
        """Gets the email_body of this CheckEmailFeaturesClientSupportOptions.  # noqa: E501


        :return: The email_body of this CheckEmailFeaturesClientSupportOptions.  # noqa: E501
        :rtype: str
        """
        return self._email_body

    @email_body.setter
    def email_body(self, email_body):
        """Sets the email_body of this CheckEmailFeaturesClientSupportOptions.


        :param email_body: The email_body of this CheckEmailFeaturesClientSupportOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_body is None:  # noqa: E501
            raise ValueError("Invalid value for `email_body`, must not be `None`")  # noqa: E501

        self._email_body = email_body

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CheckEmailFeaturesClientSupportOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CheckEmailFeaturesClientSupportOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/check_email_client_support_results.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CheckEmailClientSupportResults(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'result': 'EmailFeatureSupportResult'
    }

    attribute_map = {
        'result': 'result'
    }

    def __init__(self, result=None, local_vars_configuration=None):  # noqa: E501
        """CheckEmailClientSupportResults - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._result = None
        self.discriminator = None

        self.result = result

    @property
    def result(self):
        """Gets the result of this CheckEmailClientSupportResults.  # noqa: E501


        :return: The result of this CheckEmailClientSupportResults.  # noqa: E501
        :rtype: EmailFeatureSupportResult
        """
        return self._result

    @result.setter
    def result(self, result):
        """Sets the result of this CheckEmailClientSupportResults.


        :param result: The result of this CheckEmailClientSupportResults.  # noqa: E501
        :type: EmailFeatureSupportResult
        """
        if self.local_vars_configuration.client_side_validation and result is None:  # noqa: E501
            raise ValueError("Invalid value for `result`, must not be `None`")  # noqa: E501

        self._result = result

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CheckEmailClientSupportResults):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CheckEmailClientSupportResults):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/check_email_client_support_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CheckEmailClientSupportOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'email_body': 'str'
    }

    attribute_map = {
        'email_body': 'emailBody'
    }

    def __init__(self, email_body=None, local_vars_configuration=None):  # noqa: E501
        """CheckEmailClientSupportOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._email_body = None
        self.discriminator = None

        self.email_body = email_body

    @property
    def email_body(self):
        """Gets the email_body of this CheckEmailClientSupportOptions.  # noqa: E501


        :return: The email_body of this CheckEmailClientSupportOptions.  # noqa: E501
        :rtype: str
        """
        return self._email_body

    @email_body.setter
    def email_body(self, email_body):
        """Sets the email_body of this CheckEmailClientSupportOptions.


        :param email_body: The email_body of this CheckEmailClientSupportOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_body is None:  # noqa: E501
            raise ValueError("Invalid value for `email_body`, must not be `None`")  # noqa: E501

        self._email_body = email_body

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CheckEmailClientSupportOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CheckEmailClientSupportOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/check_email_body_results.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CheckEmailBodyResults(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'has_issues': 'bool',
        'link_issues': 'list[LinkIssue]',
        'image_issues': 'list[ImageIssue]',
        'spelling_issues': 'list[SpellingIssue]'
    }

    attribute_map = {
        'has_issues': 'hasIssues',
        'link_issues': 'linkIssues',
        'image_issues': 'imageIssues',
        'spelling_issues': 'spellingIssues'
    }

    def __init__(self, has_issues=None, link_issues=None, image_issues=None, spelling_issues=None, local_vars_configuration=None):  # noqa: E501
        """CheckEmailBodyResults - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._has_issues = None
        self._link_issues = None
        self._image_issues = None
        self._spelling_issues = None
        self.discriminator = None

        self.has_issues = has_issues
        self.link_issues = link_issues
        self.image_issues = image_issues
        self.spelling_issues = spelling_issues

    @property
    def has_issues(self):
        """Gets the has_issues of this CheckEmailBodyResults.  # noqa: E501


        :return: The has_issues of this CheckEmailBodyResults.  # noqa: E501
        :rtype: bool
        """
        return self._has_issues

    @has_issues.setter
    def has_issues(self, has_issues):
        """Sets the has_issues of this CheckEmailBodyResults.


        :param has_issues: The has_issues of this CheckEmailBodyResults.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and has_issues is None:  # noqa: E501
            raise ValueError("Invalid value for `has_issues`, must not be `None`")  # noqa: E501

        self._has_issues = has_issues

    @property
    def link_issues(self):
        """Gets the link_issues of this CheckEmailBodyResults.  # noqa: E501


        :return: The link_issues of this CheckEmailBodyResults.  # noqa: E501
        :rtype: list[LinkIssue]
        """
        return self._link_issues

    @link_issues.setter
    def link_issues(self, link_issues):
        """Sets the link_issues of this CheckEmailBodyResults.


        :param link_issues: The link_issues of this CheckEmailBodyResults.  # noqa: E501
        :type: list[LinkIssue]
        """
        if self.local_vars_configuration.client_side_validation and link_issues is None:  # noqa: E501
            raise ValueError("Invalid value for `link_issues`, must not be `None`")  # noqa: E501

        self._link_issues = link_issues

    @property
    def image_issues(self):
        """Gets the image_issues of this CheckEmailBodyResults.  # noqa: E501


        :return: The image_issues of this CheckEmailBodyResults.  # noqa: E501
        :rtype: list[ImageIssue]
        """
        return self._image_issues

    @image_issues.setter
    def image_issues(self, image_issues):
        """Sets the image_issues of this CheckEmailBodyResults.


        :param image_issues: The image_issues of this CheckEmailBodyResults.  # noqa: E501
        :type: list[ImageIssue]
        """
        if self.local_vars_configuration.client_side_validation and image_issues is None:  # noqa: E501
            raise ValueError("Invalid value for `image_issues`, must not be `None`")  # noqa: E501

        self._image_issues = image_issues

    @property
    def spelling_issues(self):
        """Gets the spelling_issues of this CheckEmailBodyResults.  # noqa: E501


        :return: The spelling_issues of this CheckEmailBodyResults.  # noqa: E501
        :rtype: list[SpellingIssue]
        """
        return self._spelling_issues

    @spelling_issues.setter
    def spelling_issues(self, spelling_issues):
        """Sets the spelling_issues of this CheckEmailBodyResults.


        :param spelling_issues: The spelling_issues of this CheckEmailBodyResults.  # noqa: E501
        :type: list[SpellingIssue]
        """
        if self.local_vars_configuration.client_side_validation and spelling_issues is None:  # noqa: E501
            raise ValueError("Invalid value for `spelling_issues`, must not be `None`")  # noqa: E501

        self._spelling_issues = spelling_issues

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CheckEmailBodyResults):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CheckEmailBodyResults):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/check_email_body_feature_support_results.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CheckEmailBodyFeatureSupportResults(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'result': 'EmailFeatureSupportResult'
    }

    attribute_map = {
        'result': 'result'
    }

    def __init__(self, result=None, local_vars_configuration=None):  # noqa: E501
        """CheckEmailBodyFeatureSupportResults - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._result = None
        self.discriminator = None

        self.result = result

    @property
    def result(self):
        """Gets the result of this CheckEmailBodyFeatureSupportResults.  # noqa: E501


        :return: The result of this CheckEmailBodyFeatureSupportResults.  # noqa: E501
        :rtype: EmailFeatureSupportResult
        """
        return self._result

    @result.setter
    def result(self, result):
        """Sets the result of this CheckEmailBodyFeatureSupportResults.


        :param result: The result of this CheckEmailBodyFeatureSupportResults.  # noqa: E501
        :type: EmailFeatureSupportResult
        """
        if self.local_vars_configuration.client_side_validation and result is None:  # noqa: E501
            raise ValueError("Invalid value for `result`, must not be `None`")  # noqa: E501

        self._result = result

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CheckEmailBodyFeatureSupportResults):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CheckEmailBodyFeatureSupportResults):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/can_send_email_results.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class CanSendEmailResults(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'is_sending_permitted': 'bool',
        'message': 'str'
    }

    attribute_map = {
        'is_sending_permitted': 'isSendingPermitted',
        'message': 'message'
    }

    def __init__(self, is_sending_permitted=None, message=None, local_vars_configuration=None):  # noqa: E501
        """CanSendEmailResults - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._is_sending_permitted = None
        self._message = None
        self.discriminator = None

        self.is_sending_permitted = is_sending_permitted
        if message is not None:
            self.message = message

    @property
    def is_sending_permitted(self):
        """Gets the is_sending_permitted of this CanSendEmailResults.  # noqa: E501


        :return: The is_sending_permitted of this CanSendEmailResults.  # noqa: E501
        :rtype: bool
        """
        return self._is_sending_permitted

    @is_sending_permitted.setter
    def is_sending_permitted(self, is_sending_permitted):
        """Sets the is_sending_permitted of this CanSendEmailResults.


        :param is_sending_permitted: The is_sending_permitted of this CanSendEmailResults.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and is_sending_permitted is None:  # noqa: E501
            raise ValueError("Invalid value for `is_sending_permitted`, must not be `None`")  # noqa: E501

        self._is_sending_permitted = is_sending_permitted

    @property
    def message(self):
        """Gets the message of this CanSendEmailResults.  # noqa: E501


        :return: The message of this CanSendEmailResults.  # noqa: E501
        :rtype: str
        """
        return self._message

    @message.setter
    def message(self, message):
        """Sets the message of this CanSendEmailResults.


        :param message: The message of this CanSendEmailResults.  # noqa: E501
        :type: str
        """

        self._message = message

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, CanSendEmailResults):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, CanSendEmailResults):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/bulk_send_email_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class BulkSendEmailOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'inbox_ids': 'list[str]',
        'send_email_options': 'SendEmailOptions'
    }

    attribute_map = {
        'inbox_ids': 'inboxIds',
        'send_email_options': 'sendEmailOptions'
    }

    def __init__(self, inbox_ids=None, send_email_options=None, local_vars_configuration=None):  # noqa: E501
        """BulkSendEmailOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._inbox_ids = None
        self._send_email_options = None
        self.discriminator = None

        self.inbox_ids = inbox_ids
        self.send_email_options = send_email_options

    @property
    def inbox_ids(self):
        """Gets the inbox_ids of this BulkSendEmailOptions.  # noqa: E501

        Inboxes to send the email from  # noqa: E501

        :return: The inbox_ids of this BulkSendEmailOptions.  # noqa: E501
        :rtype: list[str]
        """
        return self._inbox_ids

    @inbox_ids.setter
    def inbox_ids(self, inbox_ids):
        """Sets the inbox_ids of this BulkSendEmailOptions.

        Inboxes to send the email from  # noqa: E501

        :param inbox_ids: The inbox_ids of this BulkSendEmailOptions.  # noqa: E501
        :type: list[str]
        """
        if self.local_vars_configuration.client_side_validation and inbox_ids is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_ids`, must not be `None`")  # noqa: E501

        self._inbox_ids = inbox_ids

    @property
    def send_email_options(self):
        """Gets the send_email_options of this BulkSendEmailOptions.  # noqa: E501


        :return: The send_email_options of this BulkSendEmailOptions.  # noqa: E501
        :rtype: SendEmailOptions
        """
        return self._send_email_options

    @send_email_options.setter
    def send_email_options(self, send_email_options):
        """Sets the send_email_options of this BulkSendEmailOptions.


        :param send_email_options: The send_email_options of this BulkSendEmailOptions.  # noqa: E501
        :type: SendEmailOptions
        """
        if self.local_vars_configuration.client_side_validation and send_email_options is None:  # noqa: E501
            raise ValueError("Invalid value for `send_email_options`, must not be `None`")  # noqa: E501

        self._send_email_options = send_email_options

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, BulkSendEmailOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, BulkSendEmailOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/bounced_recipient_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class BouncedRecipientDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'sent_email_id': 'str',
        'recipient': 'str',
        'diagnostic_code': 'str',
        'action': 'str',
        'bounce_type': 'str',
        'status': 'str',
        'created_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'sent_email_id': 'sentEmailId',
        'recipient': 'recipient',
        'diagnostic_code': 'diagnosticCode',
        'action': 'action',
        'bounce_type': 'bounceType',
        'status': 'status',
        'created_at': 'createdAt'
    }

    def __init__(self, id=None, user_id=None, sent_email_id=None, recipient=None, diagnostic_code=None, action=None, bounce_type=None, status=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """BouncedRecipientDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._sent_email_id = None
        self._recipient = None
        self._diagnostic_code = None
        self._action = None
        self._bounce_type = None
        self._status = None
        self._created_at = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        self.sent_email_id = sent_email_id
        self.recipient = recipient
        self.diagnostic_code = diagnostic_code
        self.action = action
        self.bounce_type = bounce_type
        self.status = status
        self.created_at = created_at

    @property
    def id(self):
        """Gets the id of this BouncedRecipientDto.  # noqa: E501


        :return: The id of this BouncedRecipientDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this BouncedRecipientDto.


        :param id: The id of this BouncedRecipientDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this BouncedRecipientDto.  # noqa: E501


        :return: The user_id of this BouncedRecipientDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this BouncedRecipientDto.


        :param user_id: The user_id of this BouncedRecipientDto.  # noqa: E501
        :type: str
        """

        self._user_id = user_id

    @property
    def sent_email_id(self):
        """Gets the sent_email_id of this BouncedRecipientDto.  # noqa: E501


        :return: The sent_email_id of this BouncedRecipientDto.  # noqa: E501
        :rtype: str
        """
        return self._sent_email_id

    @sent_email_id.setter
    def sent_email_id(self, sent_email_id):
        """Sets the sent_email_id of this BouncedRecipientDto.


        :param sent_email_id: The sent_email_id of this BouncedRecipientDto.  # noqa: E501
        :type: str
        """

        self._sent_email_id = sent_email_id

    @property
    def recipient(self):
        """Gets the recipient of this BouncedRecipientDto.  # noqa: E501


        :return: The recipient of this BouncedRecipientDto.  # noqa: E501
        :rtype: str
        """
        return self._recipient

    @recipient.setter
    def recipient(self, recipient):
        """Sets the recipient of this BouncedRecipientDto.


        :param recipient: The recipient of this BouncedRecipientDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and recipient is None:  # noqa: E501
            raise ValueError("Invalid value for `recipient`, must not be `None`")  # noqa: E501

        self._recipient = recipient

    @property
    def diagnostic_code(self):
        """Gets the diagnostic_code of this BouncedRecipientDto.  # noqa: E501


        :return: The diagnostic_code of this BouncedRecipientDto.  # noqa: E501
        :rtype: str
        """
        return self._diagnostic_code

    @diagnostic_code.setter
    def diagnostic_code(self, diagnostic_code):
        """Sets the diagnostic_code of this BouncedRecipientDto.


        :param diagnostic_code: The diagnostic_code of this BouncedRecipientDto.  # noqa: E501
        :type: str
        """

        self._diagnostic_code = diagnostic_code

    @property
    def action(self):
        """Gets the action of this BouncedRecipientDto.  # noqa: E501


        :return: The action of this BouncedRecipientDto.  # noqa: E501
        :rtype: str
        """
        return self._action

    @action.setter
    def action(self, action):
        """Sets the action of this BouncedRecipientDto.


        :param action: The action of this BouncedRecipientDto.  # noqa: E501
        :type: str
        """

        self._action = action

    @property
    def bounce_type(self):
        """Gets the bounce_type of this BouncedRecipientDto.  # noqa: E501


        :return: The bounce_type of this BouncedRecipientDto.  # noqa: E501
        :rtype: str
        """
        return self._bounce_type

    @bounce_type.setter
    def bounce_type(self, bounce_type):
        """Sets the bounce_type of this BouncedRecipientDto.


        :param bounce_type: The bounce_type of this BouncedRecipientDto.  # noqa: E501
        :type: str
        """

        self._bounce_type = bounce_type

    @property
    def status(self):
        """Gets the status of this BouncedRecipientDto.  # noqa: E501


        :return: The status of this BouncedRecipientDto.  # noqa: E501
        :rtype: str
        """
        return self._status

    @status.setter
    def status(self, status):
        """Sets the status of this BouncedRecipientDto.


        :param status: The status of this BouncedRecipientDto.  # noqa: E501
        :type: str
        """

        self._status = status

    @property
    def created_at(self):
        """Gets the created_at of this BouncedRecipientDto.  # noqa: E501


        :return: The created_at of this BouncedRecipientDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this BouncedRecipientDto.


        :param created_at: The created_at of this BouncedRecipientDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, BouncedRecipientDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, BouncedRecipientDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/bounced_email_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class BouncedEmailDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'user_id': 'str',
        'notification_type': 'str',
        'sent_to_recipients': 'list[str]',
        'sender': 'str',
        'bounce_mta': 'str',
        'bounce_type': 'str',
        'bounce_recipients': 'list[str]',
        'bounce_sub_type': 'str',
        'sent_email_id': 'str',
        'subject': 'str',
        'created_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'user_id': 'userId',
        'notification_type': 'notificationType',
        'sent_to_recipients': 'sentToRecipients',
        'sender': 'sender',
        'bounce_mta': 'bounceMta',
        'bounce_type': 'bounceType',
        'bounce_recipients': 'bounceRecipients',
        'bounce_sub_type': 'bounceSubType',
        'sent_email_id': 'sentEmailId',
        'subject': 'subject',
        'created_at': 'createdAt'
    }

    def __init__(self, id=None, user_id=None, notification_type=None, sent_to_recipients=None, sender=None, bounce_mta=None, bounce_type=None, bounce_recipients=None, bounce_sub_type=None, sent_email_id=None, subject=None, created_at=None, local_vars_configuration=None):  # noqa: E501
        """BouncedEmailDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._user_id = None
        self._notification_type = None
        self._sent_to_recipients = None
        self._sender = None
        self._bounce_mta = None
        self._bounce_type = None
        self._bounce_recipients = None
        self._bounce_sub_type = None
        self._sent_email_id = None
        self._subject = None
        self._created_at = None
        self.discriminator = None

        self.id = id
        self.user_id = user_id
        self.notification_type = notification_type
        self.sent_to_recipients = sent_to_recipients
        self.sender = sender
        self.bounce_mta = bounce_mta
        self.bounce_type = bounce_type
        self.bounce_recipients = bounce_recipients
        self.bounce_sub_type = bounce_sub_type
        self.sent_email_id = sent_email_id
        self.subject = subject
        self.created_at = created_at

    @property
    def id(self):
        """Gets the id of this BouncedEmailDto.  # noqa: E501


        :return: The id of this BouncedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this BouncedEmailDto.


        :param id: The id of this BouncedEmailDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def user_id(self):
        """Gets the user_id of this BouncedEmailDto.  # noqa: E501


        :return: The user_id of this BouncedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this BouncedEmailDto.


        :param user_id: The user_id of this BouncedEmailDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def notification_type(self):
        """Gets the notification_type of this BouncedEmailDto.  # noqa: E501


        :return: The notification_type of this BouncedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._notification_type

    @notification_type.setter
    def notification_type(self, notification_type):
        """Sets the notification_type of this BouncedEmailDto.


        :param notification_type: The notification_type of this BouncedEmailDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and notification_type is None:  # noqa: E501
            raise ValueError("Invalid value for `notification_type`, must not be `None`")  # noqa: E501

        self._notification_type = notification_type

    @property
    def sent_to_recipients(self):
        """Gets the sent_to_recipients of this BouncedEmailDto.  # noqa: E501


        :return: The sent_to_recipients of this BouncedEmailDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._sent_to_recipients

    @sent_to_recipients.setter
    def sent_to_recipients(self, sent_to_recipients):
        """Sets the sent_to_recipients of this BouncedEmailDto.


        :param sent_to_recipients: The sent_to_recipients of this BouncedEmailDto.  # noqa: E501
        :type: list[str]
        """

        self._sent_to_recipients = sent_to_recipients

    @property
    def sender(self):
        """Gets the sender of this BouncedEmailDto.  # noqa: E501


        :return: The sender of this BouncedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._sender

    @sender.setter
    def sender(self, sender):
        """Sets the sender of this BouncedEmailDto.


        :param sender: The sender of this BouncedEmailDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and sender is None:  # noqa: E501
            raise ValueError("Invalid value for `sender`, must not be `None`")  # noqa: E501

        self._sender = sender

    @property
    def bounce_mta(self):
        """Gets the bounce_mta of this BouncedEmailDto.  # noqa: E501


        :return: The bounce_mta of this BouncedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._bounce_mta

    @bounce_mta.setter
    def bounce_mta(self, bounce_mta):
        """Sets the bounce_mta of this BouncedEmailDto.


        :param bounce_mta: The bounce_mta of this BouncedEmailDto.  # noqa: E501
        :type: str
        """

        self._bounce_mta = bounce_mta

    @property
    def bounce_type(self):
        """Gets the bounce_type of this BouncedEmailDto.  # noqa: E501


        :return: The bounce_type of this BouncedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._bounce_type

    @bounce_type.setter
    def bounce_type(self, bounce_type):
        """Sets the bounce_type of this BouncedEmailDto.


        :param bounce_type: The bounce_type of this BouncedEmailDto.  # noqa: E501
        :type: str
        """

        self._bounce_type = bounce_type

    @property
    def bounce_recipients(self):
        """Gets the bounce_recipients of this BouncedEmailDto.  # noqa: E501


        :return: The bounce_recipients of this BouncedEmailDto.  # noqa: E501
        :rtype: list[str]
        """
        return self._bounce_recipients

    @bounce_recipients.setter
    def bounce_recipients(self, bounce_recipients):
        """Sets the bounce_recipients of this BouncedEmailDto.


        :param bounce_recipients: The bounce_recipients of this BouncedEmailDto.  # noqa: E501
        :type: list[str]
        """

        self._bounce_recipients = bounce_recipients

    @property
    def bounce_sub_type(self):
        """Gets the bounce_sub_type of this BouncedEmailDto.  # noqa: E501


        :return: The bounce_sub_type of this BouncedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._bounce_sub_type

    @bounce_sub_type.setter
    def bounce_sub_type(self, bounce_sub_type):
        """Sets the bounce_sub_type of this BouncedEmailDto.


        :param bounce_sub_type: The bounce_sub_type of this BouncedEmailDto.  # noqa: E501
        :type: str
        """

        self._bounce_sub_type = bounce_sub_type

    @property
    def sent_email_id(self):
        """Gets the sent_email_id of this BouncedEmailDto.  # noqa: E501


        :return: The sent_email_id of this BouncedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._sent_email_id

    @sent_email_id.setter
    def sent_email_id(self, sent_email_id):
        """Sets the sent_email_id of this BouncedEmailDto.


        :param sent_email_id: The sent_email_id of this BouncedEmailDto.  # noqa: E501
        :type: str
        """

        self._sent_email_id = sent_email_id

    @property
    def subject(self):
        """Gets the subject of this BouncedEmailDto.  # noqa: E501


        :return: The subject of this BouncedEmailDto.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this BouncedEmailDto.


        :param subject: The subject of this BouncedEmailDto.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def created_at(self):
        """Gets the created_at of this BouncedEmailDto.  # noqa: E501


        :return: The created_at of this BouncedEmailDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this BouncedEmailDto.


        :param created_at: The created_at of this BouncedEmailDto.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, BouncedEmailDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, BouncedEmailDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/bounce_recipient_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class BounceRecipientProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'sent_email_id': 'str',
        'recipient': 'str',
        'bounce_type': 'str',
        'action': 'str',
        'id': 'str',
        'status': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'sent_email_id': 'sentEmailId',
        'recipient': 'recipient',
        'bounce_type': 'bounceType',
        'action': 'action',
        'id': 'id',
        'status': 'status'
    }

    def __init__(self, created_at=None, sent_email_id=None, recipient=None, bounce_type=None, action=None, id=None, status=None, local_vars_configuration=None):  # noqa: E501
        """BounceRecipientProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._sent_email_id = None
        self._recipient = None
        self._bounce_type = None
        self._action = None
        self._id = None
        self._status = None
        self.discriminator = None

        self.created_at = created_at
        self.sent_email_id = sent_email_id
        self.recipient = recipient
        self.bounce_type = bounce_type
        self.action = action
        if id is not None:
            self.id = id
        self.status = status

    @property
    def created_at(self):
        """Gets the created_at of this BounceRecipientProjection.  # noqa: E501


        :return: The created_at of this BounceRecipientProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this BounceRecipientProjection.


        :param created_at: The created_at of this BounceRecipientProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def sent_email_id(self):
        """Gets the sent_email_id of this BounceRecipientProjection.  # noqa: E501


        :return: The sent_email_id of this BounceRecipientProjection.  # noqa: E501
        :rtype: str
        """
        return self._sent_email_id

    @sent_email_id.setter
    def sent_email_id(self, sent_email_id):
        """Sets the sent_email_id of this BounceRecipientProjection.


        :param sent_email_id: The sent_email_id of this BounceRecipientProjection.  # noqa: E501
        :type: str
        """

        self._sent_email_id = sent_email_id

    @property
    def recipient(self):
        """Gets the recipient of this BounceRecipientProjection.  # noqa: E501


        :return: The recipient of this BounceRecipientProjection.  # noqa: E501
        :rtype: str
        """
        return self._recipient

    @recipient.setter
    def recipient(self, recipient):
        """Sets the recipient of this BounceRecipientProjection.


        :param recipient: The recipient of this BounceRecipientProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and recipient is None:  # noqa: E501
            raise ValueError("Invalid value for `recipient`, must not be `None`")  # noqa: E501

        self._recipient = recipient

    @property
    def bounce_type(self):
        """Gets the bounce_type of this BounceRecipientProjection.  # noqa: E501


        :return: The bounce_type of this BounceRecipientProjection.  # noqa: E501
        :rtype: str
        """
        return self._bounce_type

    @bounce_type.setter
    def bounce_type(self, bounce_type):
        """Sets the bounce_type of this BounceRecipientProjection.


        :param bounce_type: The bounce_type of this BounceRecipientProjection.  # noqa: E501
        :type: str
        """

        self._bounce_type = bounce_type

    @property
    def action(self):
        """Gets the action of this BounceRecipientProjection.  # noqa: E501


        :return: The action of this BounceRecipientProjection.  # noqa: E501
        :rtype: str
        """
        return self._action

    @action.setter
    def action(self, action):
        """Sets the action of this BounceRecipientProjection.


        :param action: The action of this BounceRecipientProjection.  # noqa: E501
        :type: str
        """

        self._action = action

    @property
    def id(self):
        """Gets the id of this BounceRecipientProjection.  # noqa: E501


        :return: The id of this BounceRecipientProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this BounceRecipientProjection.


        :param id: The id of this BounceRecipientProjection.  # noqa: E501
        :type: str
        """

        self._id = id

    @property
    def status(self):
        """Gets the status of this BounceRecipientProjection.  # noqa: E501


        :return: The status of this BounceRecipientProjection.  # noqa: E501
        :rtype: str
        """
        return self._status

    @status.setter
    def status(self, status):
        """Sets the status of this BounceRecipientProjection.


        :param status: The status of this BounceRecipientProjection.  # noqa: E501
        :type: str
        """

        self._status = status

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, BounceRecipientProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, BounceRecipientProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/bounce_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class BounceProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'sender': 'str',
        'bounce_type': 'str',
        'bounce_mta': 'str',
        'subject': 'str',
        'id': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'sender': 'sender',
        'bounce_type': 'bounceType',
        'bounce_mta': 'bounceMta',
        'subject': 'subject',
        'id': 'id'
    }

    def __init__(self, created_at=None, sender=None, bounce_type=None, bounce_mta=None, subject=None, id=None, local_vars_configuration=None):  # noqa: E501
        """BounceProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._sender = None
        self._bounce_type = None
        self._bounce_mta = None
        self._subject = None
        self._id = None
        self.discriminator = None

        self.created_at = created_at
        self.sender = sender
        self.bounce_type = bounce_type
        self.bounce_mta = bounce_mta
        self.subject = subject
        if id is not None:
            self.id = id

    @property
    def created_at(self):
        """Gets the created_at of this BounceProjection.  # noqa: E501


        :return: The created_at of this BounceProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this BounceProjection.


        :param created_at: The created_at of this BounceProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def sender(self):
        """Gets the sender of this BounceProjection.  # noqa: E501


        :return: The sender of this BounceProjection.  # noqa: E501
        :rtype: str
        """
        return self._sender

    @sender.setter
    def sender(self, sender):
        """Sets the sender of this BounceProjection.


        :param sender: The sender of this BounceProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and sender is None:  # noqa: E501
            raise ValueError("Invalid value for `sender`, must not be `None`")  # noqa: E501

        self._sender = sender

    @property
    def bounce_type(self):
        """Gets the bounce_type of this BounceProjection.  # noqa: E501


        :return: The bounce_type of this BounceProjection.  # noqa: E501
        :rtype: str
        """
        return self._bounce_type

    @bounce_type.setter
    def bounce_type(self, bounce_type):
        """Sets the bounce_type of this BounceProjection.


        :param bounce_type: The bounce_type of this BounceProjection.  # noqa: E501
        :type: str
        """

        self._bounce_type = bounce_type

    @property
    def bounce_mta(self):
        """Gets the bounce_mta of this BounceProjection.  # noqa: E501


        :return: The bounce_mta of this BounceProjection.  # noqa: E501
        :rtype: str
        """
        return self._bounce_mta

    @bounce_mta.setter
    def bounce_mta(self, bounce_mta):
        """Sets the bounce_mta of this BounceProjection.


        :param bounce_mta: The bounce_mta of this BounceProjection.  # noqa: E501
        :type: str
        """

        self._bounce_mta = bounce_mta

    @property
    def subject(self):
        """Gets the subject of this BounceProjection.  # noqa: E501


        :return: The subject of this BounceProjection.  # noqa: E501
        :rtype: str
        """
        return self._subject

    @subject.setter
    def subject(self, subject):
        """Sets the subject of this BounceProjection.


        :param subject: The subject of this BounceProjection.  # noqa: E501
        :type: str
        """

        self._subject = subject

    @property
    def id(self):
        """Gets the id of this BounceProjection.  # noqa: E501


        :return: The id of this BounceProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this BounceProjection.


        :param id: The id of this BounceProjection.  # noqa: E501
        :type: str
        """

        self._id = id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, BounceProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, BounceProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/basic_auth_options.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class BasicAuthOptions(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'username': 'str',
        'password': 'str'
    }

    attribute_map = {
        'username': 'username',
        'password': 'password'
    }

    def __init__(self, username=None, password=None, local_vars_configuration=None):  # noqa: E501
        """BasicAuthOptions - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._username = None
        self._password = None
        self.discriminator = None

        self.username = username
        self.password = password

    @property
    def username(self):
        """Gets the username of this BasicAuthOptions.  # noqa: E501


        :return: The username of this BasicAuthOptions.  # noqa: E501
        :rtype: str
        """
        return self._username

    @username.setter
    def username(self, username):
        """Sets the username of this BasicAuthOptions.


        :param username: The username of this BasicAuthOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and username is None:  # noqa: E501
            raise ValueError("Invalid value for `username`, must not be `None`")  # noqa: E501

        self._username = username

    @property
    def password(self):
        """Gets the password of this BasicAuthOptions.  # noqa: E501


        :return: The password of this BasicAuthOptions.  # noqa: E501
        :rtype: str
        """
        return self._password

    @password.setter
    def password(self, password):
        """Sets the password of this BasicAuthOptions.


        :param password: The password of this BasicAuthOptions.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and password is None:  # noqa: E501
            raise ValueError("Invalid value for `password`, must not be `None`")  # noqa: E501

        self._password = password

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, BasicAuthOptions):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, BasicAuthOptions):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/attachment_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class AttachmentProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'updated_at': 'datetime',
        'user_id': 'str',
        'content_id': 'str',
        'attachment_id': 'str',
        'name': 'str',
        'content_length': 'int',
        'content_type': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'updated_at': 'updatedAt',
        'user_id': 'userId',
        'content_id': 'contentId',
        'attachment_id': 'attachmentId',
        'name': 'name',
        'content_length': 'contentLength',
        'content_type': 'contentType'
    }

    def __init__(self, created_at=None, updated_at=None, user_id=None, content_id=None, attachment_id=None, name=None, content_length=None, content_type=None, local_vars_configuration=None):  # noqa: E501
        """AttachmentProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._updated_at = None
        self._user_id = None
        self._content_id = None
        self._attachment_id = None
        self._name = None
        self._content_length = None
        self._content_type = None
        self.discriminator = None

        self.created_at = created_at
        self.updated_at = updated_at
        self.user_id = user_id
        self.content_id = content_id
        self.attachment_id = attachment_id
        self.name = name
        self.content_length = content_length
        self.content_type = content_type

    @property
    def created_at(self):
        """Gets the created_at of this AttachmentProjection.  # noqa: E501


        :return: The created_at of this AttachmentProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this AttachmentProjection.


        :param created_at: The created_at of this AttachmentProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this AttachmentProjection.  # noqa: E501


        :return: The updated_at of this AttachmentProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this AttachmentProjection.


        :param updated_at: The updated_at of this AttachmentProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    @property
    def user_id(self):
        """Gets the user_id of this AttachmentProjection.  # noqa: E501


        :return: The user_id of this AttachmentProjection.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this AttachmentProjection.


        :param user_id: The user_id of this AttachmentProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def content_id(self):
        """Gets the content_id of this AttachmentProjection.  # noqa: E501

        Content ID of attachment.  # noqa: E501

        :return: The content_id of this AttachmentProjection.  # noqa: E501
        :rtype: str
        """
        return self._content_id

    @content_id.setter
    def content_id(self, content_id):
        """Sets the content_id of this AttachmentProjection.

        Content ID of attachment.  # noqa: E501

        :param content_id: The content_id of this AttachmentProjection.  # noqa: E501
        :type: str
        """

        self._content_id = content_id

    @property
    def attachment_id(self):
        """Gets the attachment_id of this AttachmentProjection.  # noqa: E501

        Attachment ID  # noqa: E501

        :return: The attachment_id of this AttachmentProjection.  # noqa: E501
        :rtype: str
        """
        return self._attachment_id

    @attachment_id.setter
    def attachment_id(self, attachment_id):
        """Sets the attachment_id of this AttachmentProjection.

        Attachment ID  # noqa: E501

        :param attachment_id: The attachment_id of this AttachmentProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and attachment_id is None:  # noqa: E501
            raise ValueError("Invalid value for `attachment_id`, must not be `None`")  # noqa: E501

        self._attachment_id = attachment_id

    @property
    def name(self):
        """Gets the name of this AttachmentProjection.  # noqa: E501


        :return: The name of this AttachmentProjection.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this AttachmentProjection.


        :param name: The name of this AttachmentProjection.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def content_length(self):
        """Gets the content_length of this AttachmentProjection.  # noqa: E501

        Content length of attachment in bytes  # noqa: E501

        :return: The content_length of this AttachmentProjection.  # noqa: E501
        :rtype: int
        """
        return self._content_length

    @content_length.setter
    def content_length(self, content_length):
        """Sets the content_length of this AttachmentProjection.

        Content length of attachment in bytes  # noqa: E501

        :param content_length: The content_length of this AttachmentProjection.  # noqa: E501
        :type: int
        """

        self._content_length = content_length

    @property
    def content_type(self):
        """Gets the content_type of this AttachmentProjection.  # noqa: E501

        Content type of attachment.  # noqa: E501

        :return: The content_type of this AttachmentProjection.  # noqa: E501
        :rtype: str
        """
        return self._content_type

    @content_type.setter
    def content_type(self, content_type):
        """Sets the content_type of this AttachmentProjection.

        Content type of attachment.  # noqa: E501

        :param content_type: The content_type of this AttachmentProjection.  # noqa: E501
        :type: str
        """

        self._content_type = content_type

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, AttachmentProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, AttachmentProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/attachment_meta_data.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class AttachmentMetaData(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'name': 'str',
        'content_type': 'str',
        'content_length': 'int',
        'id': 'str',
        'content_id': 'str'
    }

    attribute_map = {
        'name': 'name',
        'content_type': 'contentType',
        'content_length': 'contentLength',
        'id': 'id',
        'content_id': 'contentId'
    }

    def __init__(self, name=None, content_type=None, content_length=None, id=None, content_id=None, local_vars_configuration=None):  # noqa: E501
        """AttachmentMetaData - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._name = None
        self._content_type = None
        self._content_length = None
        self._id = None
        self._content_id = None
        self.discriminator = None

        self.name = name
        self.content_type = content_type
        self.content_length = content_length
        self.id = id
        self.content_id = content_id

    @property
    def name(self):
        """Gets the name of this AttachmentMetaData.  # noqa: E501

        Name of attachment if given  # noqa: E501

        :return: The name of this AttachmentMetaData.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this AttachmentMetaData.

        Name of attachment if given  # noqa: E501

        :param name: The name of this AttachmentMetaData.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and name is None:  # noqa: E501
            raise ValueError("Invalid value for `name`, must not be `None`")  # noqa: E501

        self._name = name

    @property
    def content_type(self):
        """Gets the content_type of this AttachmentMetaData.  # noqa: E501

        Content type of attachment such as `image/png`  # noqa: E501

        :return: The content_type of this AttachmentMetaData.  # noqa: E501
        :rtype: str
        """
        return self._content_type

    @content_type.setter
    def content_type(self, content_type):
        """Sets the content_type of this AttachmentMetaData.

        Content type of attachment such as `image/png`  # noqa: E501

        :param content_type: The content_type of this AttachmentMetaData.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and content_type is None:  # noqa: E501
            raise ValueError("Invalid value for `content_type`, must not be `None`")  # noqa: E501

        self._content_type = content_type

    @property
    def content_length(self):
        """Gets the content_length of this AttachmentMetaData.  # noqa: E501

        Size of attachment in bytes  # noqa: E501

        :return: The content_length of this AttachmentMetaData.  # noqa: E501
        :rtype: int
        """
        return self._content_length

    @content_length.setter
    def content_length(self, content_length):
        """Sets the content_length of this AttachmentMetaData.

        Size of attachment in bytes  # noqa: E501

        :param content_length: The content_length of this AttachmentMetaData.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and content_length is None:  # noqa: E501
            raise ValueError("Invalid value for `content_length`, must not be `None`")  # noqa: E501

        self._content_length = content_length

    @property
    def id(self):
        """Gets the id of this AttachmentMetaData.  # noqa: E501

        ID of attachment. Can be used to with attachment controller endpoints to download attachment or with sending methods to attach to an email.  # noqa: E501

        :return: The id of this AttachmentMetaData.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this AttachmentMetaData.

        ID of attachment. Can be used to with attachment controller endpoints to download attachment or with sending methods to attach to an email.  # noqa: E501

        :param id: The id of this AttachmentMetaData.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def content_id(self):
        """Gets the content_id of this AttachmentMetaData.  # noqa: E501

        CID of attachment  # noqa: E501

        :return: The content_id of this AttachmentMetaData.  # noqa: E501
        :rtype: str
        """
        return self._content_id

    @content_id.setter
    def content_id(self, content_id):
        """Sets the content_id of this AttachmentMetaData.

        CID of attachment  # noqa: E501

        :param content_id: The content_id of this AttachmentMetaData.  # noqa: E501
        :type: str
        """

        self._content_id = content_id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, AttachmentMetaData):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, AttachmentMetaData):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/attachment_entity.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class AttachmentEntity(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'attachment_id': 'str',
        'bucket': 'str',
        'user_id': 'str',
        'content_type': 'str',
        'content_length': 'int',
        'content_id': 'str',
        'name': 'str',
        'inbox_id': 'str',
        'created_at': 'datetime',
        'updated_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'attachment_id': 'attachmentId',
        'bucket': 'bucket',
        'user_id': 'userId',
        'content_type': 'contentType',
        'content_length': 'contentLength',
        'content_id': 'contentId',
        'name': 'name',
        'inbox_id': 'inboxId',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt'
    }

    def __init__(self, id=None, attachment_id=None, bucket=None, user_id=None, content_type=None, content_length=None, content_id=None, name=None, inbox_id=None, created_at=None, updated_at=None, local_vars_configuration=None):  # noqa: E501
        """AttachmentEntity - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._attachment_id = None
        self._bucket = None
        self._user_id = None
        self._content_type = None
        self._content_length = None
        self._content_id = None
        self._name = None
        self._inbox_id = None
        self._created_at = None
        self._updated_at = None
        self.discriminator = None

        if id is not None:
            self.id = id
        self.attachment_id = attachment_id
        if bucket is not None:
            self.bucket = bucket
        self.user_id = user_id
        if content_type is not None:
            self.content_type = content_type
        if content_length is not None:
            self.content_length = content_length
        if content_id is not None:
            self.content_id = content_id
        if name is not None:
            self.name = name
        if inbox_id is not None:
            self.inbox_id = inbox_id
        self.created_at = created_at
        self.updated_at = updated_at

    @property
    def id(self):
        """Gets the id of this AttachmentEntity.  # noqa: E501


        :return: The id of this AttachmentEntity.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this AttachmentEntity.


        :param id: The id of this AttachmentEntity.  # noqa: E501
        :type: str
        """

        self._id = id

    @property
    def attachment_id(self):
        """Gets the attachment_id of this AttachmentEntity.  # noqa: E501


        :return: The attachment_id of this AttachmentEntity.  # noqa: E501
        :rtype: str
        """
        return self._attachment_id

    @attachment_id.setter
    def attachment_id(self, attachment_id):
        """Sets the attachment_id of this AttachmentEntity.


        :param attachment_id: The attachment_id of this AttachmentEntity.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and attachment_id is None:  # noqa: E501
            raise ValueError("Invalid value for `attachment_id`, must not be `None`")  # noqa: E501

        self._attachment_id = attachment_id

    @property
    def bucket(self):
        """Gets the bucket of this AttachmentEntity.  # noqa: E501


        :return: The bucket of this AttachmentEntity.  # noqa: E501
        :rtype: str
        """
        return self._bucket

    @bucket.setter
    def bucket(self, bucket):
        """Sets the bucket of this AttachmentEntity.


        :param bucket: The bucket of this AttachmentEntity.  # noqa: E501
        :type: str
        """

        self._bucket = bucket

    @property
    def user_id(self):
        """Gets the user_id of this AttachmentEntity.  # noqa: E501


        :return: The user_id of this AttachmentEntity.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this AttachmentEntity.


        :param user_id: The user_id of this AttachmentEntity.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def content_type(self):
        """Gets the content_type of this AttachmentEntity.  # noqa: E501


        :return: The content_type of this AttachmentEntity.  # noqa: E501
        :rtype: str
        """
        return self._content_type

    @content_type.setter
    def content_type(self, content_type):
        """Sets the content_type of this AttachmentEntity.


        :param content_type: The content_type of this AttachmentEntity.  # noqa: E501
        :type: str
        """

        self._content_type = content_type

    @property
    def content_length(self):
        """Gets the content_length of this AttachmentEntity.  # noqa: E501


        :return: The content_length of this AttachmentEntity.  # noqa: E501
        :rtype: int
        """
        return self._content_length

    @content_length.setter
    def content_length(self, content_length):
        """Sets the content_length of this AttachmentEntity.


        :param content_length: The content_length of this AttachmentEntity.  # noqa: E501
        :type: int
        """

        self._content_length = content_length

    @property
    def content_id(self):
        """Gets the content_id of this AttachmentEntity.  # noqa: E501


        :return: The content_id of this AttachmentEntity.  # noqa: E501
        :rtype: str
        """
        return self._content_id

    @content_id.setter
    def content_id(self, content_id):
        """Sets the content_id of this AttachmentEntity.


        :param content_id: The content_id of this AttachmentEntity.  # noqa: E501
        :type: str
        """

        self._content_id = content_id

    @property
    def name(self):
        """Gets the name of this AttachmentEntity.  # noqa: E501


        :return: The name of this AttachmentEntity.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this AttachmentEntity.


        :param name: The name of this AttachmentEntity.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def inbox_id(self):
        """Gets the inbox_id of this AttachmentEntity.  # noqa: E501


        :return: The inbox_id of this AttachmentEntity.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this AttachmentEntity.


        :param inbox_id: The inbox_id of this AttachmentEntity.  # noqa: E501
        :type: str
        """

        self._inbox_id = inbox_id

    @property
    def created_at(self):
        """Gets the created_at of this AttachmentEntity.  # noqa: E501


        :return: The created_at of this AttachmentEntity.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this AttachmentEntity.


        :param created_at: The created_at of this AttachmentEntity.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this AttachmentEntity.  # noqa: E501


        :return: The updated_at of this AttachmentEntity.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this AttachmentEntity.


        :param updated_at: The updated_at of this AttachmentEntity.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, AttachmentEntity):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, AttachmentEntity):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/alias_projection.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class AliasProjection(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'created_at': 'datetime',
        'updated_at': 'datetime',
        'inbox_id': 'str',
        'email_address': 'str',
        'user_id': 'str',
        'use_threads': 'bool',
        'name': 'str',
        'id': 'str'
    }

    attribute_map = {
        'created_at': 'createdAt',
        'updated_at': 'updatedAt',
        'inbox_id': 'inboxId',
        'email_address': 'emailAddress',
        'user_id': 'userId',
        'use_threads': 'useThreads',
        'name': 'name',
        'id': 'id'
    }

    def __init__(self, created_at=None, updated_at=None, inbox_id=None, email_address=None, user_id=None, use_threads=None, name=None, id=None, local_vars_configuration=None):  # noqa: E501
        """AliasProjection - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._created_at = None
        self._updated_at = None
        self._inbox_id = None
        self._email_address = None
        self._user_id = None
        self._use_threads = None
        self._name = None
        self._id = None
        self.discriminator = None

        self.created_at = created_at
        self.updated_at = updated_at
        self.inbox_id = inbox_id
        self.email_address = email_address
        self.user_id = user_id
        if use_threads is not None:
            self.use_threads = use_threads
        if name is not None:
            self.name = name
        self.id = id

    @property
    def created_at(self):
        """Gets the created_at of this AliasProjection.  # noqa: E501


        :return: The created_at of this AliasProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this AliasProjection.


        :param created_at: The created_at of this AliasProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and created_at is None:  # noqa: E501
            raise ValueError("Invalid value for `created_at`, must not be `None`")  # noqa: E501

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this AliasProjection.  # noqa: E501


        :return: The updated_at of this AliasProjection.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this AliasProjection.


        :param updated_at: The updated_at of this AliasProjection.  # noqa: E501
        :type: datetime
        """
        if self.local_vars_configuration.client_side_validation and updated_at is None:  # noqa: E501
            raise ValueError("Invalid value for `updated_at`, must not be `None`")  # noqa: E501

        self._updated_at = updated_at

    @property
    def inbox_id(self):
        """Gets the inbox_id of this AliasProjection.  # noqa: E501


        :return: The inbox_id of this AliasProjection.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this AliasProjection.


        :param inbox_id: The inbox_id of this AliasProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def email_address(self):
        """Gets the email_address of this AliasProjection.  # noqa: E501


        :return: The email_address of this AliasProjection.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this AliasProjection.


        :param email_address: The email_address of this AliasProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    @property
    def user_id(self):
        """Gets the user_id of this AliasProjection.  # noqa: E501


        :return: The user_id of this AliasProjection.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this AliasProjection.


        :param user_id: The user_id of this AliasProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def use_threads(self):
        """Gets the use_threads of this AliasProjection.  # noqa: E501


        :return: The use_threads of this AliasProjection.  # noqa: E501
        :rtype: bool
        """
        return self._use_threads

    @use_threads.setter
    def use_threads(self, use_threads):
        """Sets the use_threads of this AliasProjection.


        :param use_threads: The use_threads of this AliasProjection.  # noqa: E501
        :type: bool
        """

        self._use_threads = use_threads

    @property
    def name(self):
        """Gets the name of this AliasProjection.  # noqa: E501


        :return: The name of this AliasProjection.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this AliasProjection.


        :param name: The name of this AliasProjection.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def id(self):
        """Gets the id of this AliasProjection.  # noqa: E501


        :return: The id of this AliasProjection.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this AliasProjection.


        :param id: The id of this AliasProjection.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, AliasProjection):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, AliasProjection):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/alias_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class AliasDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'id': 'str',
        'email_address': 'str',
        'masked_email_address': 'str',
        'user_id': 'str',
        'inbox_id': 'str',
        'name': 'str',
        'use_threads': 'bool',
        'is_verified': 'bool',
        'domain_id': 'str',
        'created_at': 'datetime',
        'updated_at': 'datetime'
    }

    attribute_map = {
        'id': 'id',
        'email_address': 'emailAddress',
        'masked_email_address': 'maskedEmailAddress',
        'user_id': 'userId',
        'inbox_id': 'inboxId',
        'name': 'name',
        'use_threads': 'useThreads',
        'is_verified': 'isVerified',
        'domain_id': 'domainId',
        'created_at': 'createdAt',
        'updated_at': 'updatedAt'
    }

    def __init__(self, id=None, email_address=None, masked_email_address=None, user_id=None, inbox_id=None, name=None, use_threads=None, is_verified=None, domain_id=None, created_at=None, updated_at=None, local_vars_configuration=None):  # noqa: E501
        """AliasDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._id = None
        self._email_address = None
        self._masked_email_address = None
        self._user_id = None
        self._inbox_id = None
        self._name = None
        self._use_threads = None
        self._is_verified = None
        self._domain_id = None
        self._created_at = None
        self._updated_at = None
        self.discriminator = None

        self.id = id
        self.email_address = email_address
        self.masked_email_address = masked_email_address
        self.user_id = user_id
        self.inbox_id = inbox_id
        self.name = name
        self.use_threads = use_threads
        self.is_verified = is_verified
        self.domain_id = domain_id
        self.created_at = created_at
        self.updated_at = updated_at

    @property
    def id(self):
        """Gets the id of this AliasDto.  # noqa: E501


        :return: The id of this AliasDto.  # noqa: E501
        :rtype: str
        """
        return self._id

    @id.setter
    def id(self, id):
        """Sets the id of this AliasDto.


        :param id: The id of this AliasDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and id is None:  # noqa: E501
            raise ValueError("Invalid value for `id`, must not be `None`")  # noqa: E501

        self._id = id

    @property
    def email_address(self):
        """Gets the email_address of this AliasDto.  # noqa: E501

        The alias's email address for receiving email  # noqa: E501

        :return: The email_address of this AliasDto.  # noqa: E501
        :rtype: str
        """
        return self._email_address

    @email_address.setter
    def email_address(self, email_address):
        """Sets the email_address of this AliasDto.

        The alias's email address for receiving email  # noqa: E501

        :param email_address: The email_address of this AliasDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and email_address is None:  # noqa: E501
            raise ValueError("Invalid value for `email_address`, must not be `None`")  # noqa: E501

        self._email_address = email_address

    @property
    def masked_email_address(self):
        """Gets the masked_email_address of this AliasDto.  # noqa: E501

        The underlying email address that is hidden and will received forwarded email  # noqa: E501

        :return: The masked_email_address of this AliasDto.  # noqa: E501
        :rtype: str
        """
        return self._masked_email_address

    @masked_email_address.setter
    def masked_email_address(self, masked_email_address):
        """Sets the masked_email_address of this AliasDto.

        The underlying email address that is hidden and will received forwarded email  # noqa: E501

        :param masked_email_address: The masked_email_address of this AliasDto.  # noqa: E501
        :type: str
        """

        self._masked_email_address = masked_email_address

    @property
    def user_id(self):
        """Gets the user_id of this AliasDto.  # noqa: E501


        :return: The user_id of this AliasDto.  # noqa: E501
        :rtype: str
        """
        return self._user_id

    @user_id.setter
    def user_id(self, user_id):
        """Sets the user_id of this AliasDto.


        :param user_id: The user_id of this AliasDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and user_id is None:  # noqa: E501
            raise ValueError("Invalid value for `user_id`, must not be `None`")  # noqa: E501

        self._user_id = user_id

    @property
    def inbox_id(self):
        """Gets the inbox_id of this AliasDto.  # noqa: E501

        Inbox that is associated with the alias  # noqa: E501

        :return: The inbox_id of this AliasDto.  # noqa: E501
        :rtype: str
        """
        return self._inbox_id

    @inbox_id.setter
    def inbox_id(self, inbox_id):
        """Sets the inbox_id of this AliasDto.

        Inbox that is associated with the alias  # noqa: E501

        :param inbox_id: The inbox_id of this AliasDto.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and inbox_id is None:  # noqa: E501
            raise ValueError("Invalid value for `inbox_id`, must not be `None`")  # noqa: E501

        self._inbox_id = inbox_id

    @property
    def name(self):
        """Gets the name of this AliasDto.  # noqa: E501


        :return: The name of this AliasDto.  # noqa: E501
        :rtype: str
        """
        return self._name

    @name.setter
    def name(self, name):
        """Sets the name of this AliasDto.


        :param name: The name of this AliasDto.  # noqa: E501
        :type: str
        """

        self._name = name

    @property
    def use_threads(self):
        """Gets the use_threads of this AliasDto.  # noqa: E501

        If alias will generate response threads or not when email are received by it  # noqa: E501

        :return: The use_threads of this AliasDto.  # noqa: E501
        :rtype: bool
        """
        return self._use_threads

    @use_threads.setter
    def use_threads(self, use_threads):
        """Sets the use_threads of this AliasDto.

        If alias will generate response threads or not when email are received by it  # noqa: E501

        :param use_threads: The use_threads of this AliasDto.  # noqa: E501
        :type: bool
        """

        self._use_threads = use_threads

    @property
    def is_verified(self):
        """Gets the is_verified of this AliasDto.  # noqa: E501

        Has the alias been verified. You must verify an alias if the masked email address has not yet been verified by your account  # noqa: E501

        :return: The is_verified of this AliasDto.  # noqa: E501
        :rtype: bool
        """
        return self._is_verified

    @is_verified.setter
    def is_verified(self, is_verified):
        """Sets the is_verified of this AliasDto.

        Has the alias been verified. You must verify an alias if the masked email address has not yet been verified by your account  # noqa: E501

        :param is_verified: The is_verified of this AliasDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and is_verified is None:  # noqa: E501
            raise ValueError("Invalid value for `is_verified`, must not be `None`")  # noqa: E501

        self._is_verified = is_verified

    @property
    def domain_id(self):
        """Gets the domain_id of this AliasDto.  # noqa: E501

        Domain ID associated with the alias  # noqa: E501

        :return: The domain_id of this AliasDto.  # noqa: E501
        :rtype: str
        """
        return self._domain_id

    @domain_id.setter
    def domain_id(self, domain_id):
        """Sets the domain_id of this AliasDto.

        Domain ID associated with the alias  # noqa: E501

        :param domain_id: The domain_id of this AliasDto.  # noqa: E501
        :type: str
        """

        self._domain_id = domain_id

    @property
    def created_at(self):
        """Gets the created_at of this AliasDto.  # noqa: E501


        :return: The created_at of this AliasDto.  # noqa: E501
        :rtype: datetime
        """
        return self._created_at

    @created_at.setter
    def created_at(self, created_at):
        """Sets the created_at of this AliasDto.


        :param created_at: The created_at of this AliasDto.  # noqa: E501
        :type: datetime
        """

        self._created_at = created_at

    @property
    def updated_at(self):
        """Gets the updated_at of this AliasDto.  # noqa: E501


        :return: The updated_at of this AliasDto.  # noqa: E501
        :rtype: datetime
        """
        return self._updated_at

    @updated_at.setter
    def updated_at(self, updated_at):
        """Sets the updated_at of this AliasDto.


        :param updated_at: The updated_at of this AliasDto.  # noqa: E501
        :type: datetime
        """

        self._updated_at = updated_at

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, AliasDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, AliasDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/account_bounce_block_dto.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class AccountBounceBlockDto(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'is_sending_blocked': 'bool',
        'bounce_count': 'int',
        'bounce_count_today': 'int',
        'maximum_daily_bounces': 'int',
        'maximum_account_bounces': 'int'
    }

    attribute_map = {
        'is_sending_blocked': 'isSendingBlocked',
        'bounce_count': 'bounceCount',
        'bounce_count_today': 'bounceCountToday',
        'maximum_daily_bounces': 'maximumDailyBounces',
        'maximum_account_bounces': 'maximumAccountBounces'
    }

    def __init__(self, is_sending_blocked=None, bounce_count=None, bounce_count_today=None, maximum_daily_bounces=None, maximum_account_bounces=None, local_vars_configuration=None):  # noqa: E501
        """AccountBounceBlockDto - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._is_sending_blocked = None
        self._bounce_count = None
        self._bounce_count_today = None
        self._maximum_daily_bounces = None
        self._maximum_account_bounces = None
        self.discriminator = None

        self.is_sending_blocked = is_sending_blocked
        self.bounce_count = bounce_count
        self.bounce_count_today = bounce_count_today
        self.maximum_daily_bounces = maximum_daily_bounces
        self.maximum_account_bounces = maximum_account_bounces

    @property
    def is_sending_blocked(self):
        """Gets the is_sending_blocked of this AccountBounceBlockDto.  # noqa: E501


        :return: The is_sending_blocked of this AccountBounceBlockDto.  # noqa: E501
        :rtype: bool
        """
        return self._is_sending_blocked

    @is_sending_blocked.setter
    def is_sending_blocked(self, is_sending_blocked):
        """Sets the is_sending_blocked of this AccountBounceBlockDto.


        :param is_sending_blocked: The is_sending_blocked of this AccountBounceBlockDto.  # noqa: E501
        :type: bool
        """
        if self.local_vars_configuration.client_side_validation and is_sending_blocked is None:  # noqa: E501
            raise ValueError("Invalid value for `is_sending_blocked`, must not be `None`")  # noqa: E501

        self._is_sending_blocked = is_sending_blocked

    @property
    def bounce_count(self):
        """Gets the bounce_count of this AccountBounceBlockDto.  # noqa: E501


        :return: The bounce_count of this AccountBounceBlockDto.  # noqa: E501
        :rtype: int
        """
        return self._bounce_count

    @bounce_count.setter
    def bounce_count(self, bounce_count):
        """Sets the bounce_count of this AccountBounceBlockDto.


        :param bounce_count: The bounce_count of this AccountBounceBlockDto.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and bounce_count is None:  # noqa: E501
            raise ValueError("Invalid value for `bounce_count`, must not be `None`")  # noqa: E501

        self._bounce_count = bounce_count

    @property
    def bounce_count_today(self):
        """Gets the bounce_count_today of this AccountBounceBlockDto.  # noqa: E501


        :return: The bounce_count_today of this AccountBounceBlockDto.  # noqa: E501
        :rtype: int
        """
        return self._bounce_count_today

    @bounce_count_today.setter
    def bounce_count_today(self, bounce_count_today):
        """Sets the bounce_count_today of this AccountBounceBlockDto.


        :param bounce_count_today: The bounce_count_today of this AccountBounceBlockDto.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and bounce_count_today is None:  # noqa: E501
            raise ValueError("Invalid value for `bounce_count_today`, must not be `None`")  # noqa: E501

        self._bounce_count_today = bounce_count_today

    @property
    def maximum_daily_bounces(self):
        """Gets the maximum_daily_bounces of this AccountBounceBlockDto.  # noqa: E501


        :return: The maximum_daily_bounces of this AccountBounceBlockDto.  # noqa: E501
        :rtype: int
        """
        return self._maximum_daily_bounces

    @maximum_daily_bounces.setter
    def maximum_daily_bounces(self, maximum_daily_bounces):
        """Sets the maximum_daily_bounces of this AccountBounceBlockDto.


        :param maximum_daily_bounces: The maximum_daily_bounces of this AccountBounceBlockDto.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and maximum_daily_bounces is None:  # noqa: E501
            raise ValueError("Invalid value for `maximum_daily_bounces`, must not be `None`")  # noqa: E501

        self._maximum_daily_bounces = maximum_daily_bounces

    @property
    def maximum_account_bounces(self):
        """Gets the maximum_account_bounces of this AccountBounceBlockDto.  # noqa: E501


        :return: The maximum_account_bounces of this AccountBounceBlockDto.  # noqa: E501
        :rtype: int
        """
        return self._maximum_account_bounces

    @maximum_account_bounces.setter
    def maximum_account_bounces(self, maximum_account_bounces):
        """Sets the maximum_account_bounces of this AccountBounceBlockDto.


        :param maximum_account_bounces: The maximum_account_bounces of this AccountBounceBlockDto.  # noqa: E501
        :type: int
        """
        if self.local_vars_configuration.client_side_validation and maximum_account_bounces is None:  # noqa: E501
            raise ValueError("Invalid value for `maximum_account_bounces`, must not be `None`")  # noqa: E501

        self._maximum_account_bounces = maximum_account_bounces

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, AccountBounceBlockDto):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, AccountBounceBlockDto):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/abstract_webhook_payload.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


import pprint
import re  # noqa: F401

import six

from mailslurp_client.configuration import Configuration


class AbstractWebhookPayload(object):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    """
    Attributes:
      openapi_types (dict): The key is attribute name
                            and the value is attribute type.
      attribute_map (dict): The key is attribute name
                            and the value is json key in definition.
    """
    openapi_types = {
        'event_name': 'str',
        'message_id': 'str',
        'webhook_id': 'str',
        'webhook_name': 'str'
    }

    attribute_map = {
        'event_name': 'eventName',
        'message_id': 'messageId',
        'webhook_id': 'webhookId',
        'webhook_name': 'webhookName'
    }

    def __init__(self, event_name=None, message_id=None, webhook_id=None, webhook_name=None, local_vars_configuration=None):  # noqa: E501
        """AbstractWebhookPayload - a model defined in OpenAPI"""  # noqa: E501
        if local_vars_configuration is None:
            local_vars_configuration = Configuration()
        self.local_vars_configuration = local_vars_configuration

        self._event_name = None
        self._message_id = None
        self._webhook_id = None
        self._webhook_name = None
        self.discriminator = None

        self.event_name = event_name
        self.message_id = message_id
        self.webhook_id = webhook_id
        if webhook_name is not None:
            self.webhook_name = webhook_name

    @property
    def event_name(self):
        """Gets the event_name of this AbstractWebhookPayload.  # noqa: E501


        :return: The event_name of this AbstractWebhookPayload.  # noqa: E501
        :rtype: str
        """
        return self._event_name

    @event_name.setter
    def event_name(self, event_name):
        """Sets the event_name of this AbstractWebhookPayload.


        :param event_name: The event_name of this AbstractWebhookPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and event_name is None:  # noqa: E501
            raise ValueError("Invalid value for `event_name`, must not be `None`")  # noqa: E501
        allowed_values = ["EMAIL_RECEIVED", "NEW_EMAIL", "NEW_CONTACT", "NEW_ATTACHMENT", "EMAIL_OPENED", "EMAIL_READ", "DELIVERY_STATUS", "BOUNCE", "BOUNCE_RECIPIENT", "NEW_SMS"]  # noqa: E501
        if self.local_vars_configuration.client_side_validation and event_name not in allowed_values:  # noqa: E501
            raise ValueError(
                "Invalid value for `event_name` ({0}), must be one of {1}"  # noqa: E501
                .format(event_name, allowed_values)
            )

        self._event_name = event_name

    @property
    def message_id(self):
        """Gets the message_id of this AbstractWebhookPayload.  # noqa: E501


        :return: The message_id of this AbstractWebhookPayload.  # noqa: E501
        :rtype: str
        """
        return self._message_id

    @message_id.setter
    def message_id(self, message_id):
        """Sets the message_id of this AbstractWebhookPayload.


        :param message_id: The message_id of this AbstractWebhookPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and message_id is None:  # noqa: E501
            raise ValueError("Invalid value for `message_id`, must not be `None`")  # noqa: E501

        self._message_id = message_id

    @property
    def webhook_id(self):
        """Gets the webhook_id of this AbstractWebhookPayload.  # noqa: E501


        :return: The webhook_id of this AbstractWebhookPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_id

    @webhook_id.setter
    def webhook_id(self, webhook_id):
        """Sets the webhook_id of this AbstractWebhookPayload.


        :param webhook_id: The webhook_id of this AbstractWebhookPayload.  # noqa: E501
        :type: str
        """
        if self.local_vars_configuration.client_side_validation and webhook_id is None:  # noqa: E501
            raise ValueError("Invalid value for `webhook_id`, must not be `None`")  # noqa: E501

        self._webhook_id = webhook_id

    @property
    def webhook_name(self):
        """Gets the webhook_name of this AbstractWebhookPayload.  # noqa: E501


        :return: The webhook_name of this AbstractWebhookPayload.  # noqa: E501
        :rtype: str
        """
        return self._webhook_name

    @webhook_name.setter
    def webhook_name(self, webhook_name):
        """Sets the webhook_name of this AbstractWebhookPayload.


        :param webhook_name: The webhook_name of this AbstractWebhookPayload.  # noqa: E501
        :type: str
        """

        self._webhook_name = webhook_name

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}

        for attr, _ in six.iteritems(self.openapi_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value

        return result

    def to_str(self):
        """Returns the string representation of the model"""
        return pprint.pformat(self.to_dict())

    def __repr__(self):
        """For `print` and `pprint`"""
        return self.to_str()

    def __eq__(self, other):
        """Returns true if both objects are equal"""
        if not isinstance(other, AbstractWebhookPayload):
            return False

        return self.to_dict() == other.to_dict()

    def __ne__(self, other):
        """Returns true if both objects are not equal"""
        if not isinstance(other, AbstractWebhookPayload):
            return True

        return self.to_dict() != other.to_dict()

mailslurp_client/models/__init__.py

# coding: utf-8

# flake8: noqa
"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

# import models into model package
from mailslurp_client.models.abstract_webhook_payload import AbstractWebhookPayload
from mailslurp_client.models.account_bounce_block_dto import AccountBounceBlockDto
from mailslurp_client.models.alias_dto import AliasDto
from mailslurp_client.models.alias_projection import AliasProjection
from mailslurp_client.models.attachment_entity import AttachmentEntity
from mailslurp_client.models.attachment_meta_data import AttachmentMetaData
from mailslurp_client.models.attachment_projection import AttachmentProjection
from mailslurp_client.models.basic_auth_options import BasicAuthOptions
from mailslurp_client.models.bounce_projection import BounceProjection
from mailslurp_client.models.bounce_recipient_projection import BounceRecipientProjection
from mailslurp_client.models.bounced_email_dto import BouncedEmailDto
from mailslurp_client.models.bounced_recipient_dto import BouncedRecipientDto
from mailslurp_client.models.bulk_send_email_options import BulkSendEmailOptions
from mailslurp_client.models.can_send_email_results import CanSendEmailResults
from mailslurp_client.models.check_email_body_feature_support_results import CheckEmailBodyFeatureSupportResults
from mailslurp_client.models.check_email_body_results import CheckEmailBodyResults
from mailslurp_client.models.check_email_client_support_options import CheckEmailClientSupportOptions
from mailslurp_client.models.check_email_client_support_results import CheckEmailClientSupportResults
from mailslurp_client.models.check_email_features_client_support_options import CheckEmailFeaturesClientSupportOptions
from mailslurp_client.models.check_email_features_client_support_results import CheckEmailFeaturesClientSupportResults
from mailslurp_client.models.complaint import Complaint
from mailslurp_client.models.condition_option import ConditionOption
from mailslurp_client.models.connector_dto import ConnectorDto
from mailslurp_client.models.connector_imap_connection_dto import ConnectorImapConnectionDto
from mailslurp_client.models.connector_projection import ConnectorProjection
from mailslurp_client.models.connector_smtp_connection_dto import ConnectorSmtpConnectionDto
from mailslurp_client.models.connector_sync_event_dto import ConnectorSyncEventDto
from mailslurp_client.models.connector_sync_event_projection import ConnectorSyncEventProjection
from mailslurp_client.models.connector_sync_request_result import ConnectorSyncRequestResult
from mailslurp_client.models.connector_sync_request_result_exception import ConnectorSyncRequestResultException
from mailslurp_client.models.connector_sync_request_result_exception_cause import ConnectorSyncRequestResultExceptionCause
from mailslurp_client.models.connector_sync_request_result_exception_cause_stack_trace import ConnectorSyncRequestResultExceptionCauseStackTrace
from mailslurp_client.models.connector_sync_result import ConnectorSyncResult
from mailslurp_client.models.contact_dto import ContactDto
from mailslurp_client.models.contact_projection import ContactProjection
from mailslurp_client.models.content_match_options import ContentMatchOptions
from mailslurp_client.models.count_dto import CountDto
from mailslurp_client.models.create_alias_options import CreateAliasOptions
from mailslurp_client.models.create_connector_imap_connection_options import CreateConnectorImapConnectionOptions
from mailslurp_client.models.create_connector_options import CreateConnectorOptions
from mailslurp_client.models.create_connector_smtp_connection_options import CreateConnectorSmtpConnectionOptions
from mailslurp_client.models.create_contact_options import CreateContactOptions
from mailslurp_client.models.create_domain_options import CreateDomainOptions
from mailslurp_client.models.create_emergency_address_options import CreateEmergencyAddressOptions
from mailslurp_client.models.create_group_options import CreateGroupOptions
from mailslurp_client.models.create_inbox_dto import CreateInboxDto
from mailslurp_client.models.create_inbox_forwarder_options import CreateInboxForwarderOptions
from mailslurp_client.models.create_inbox_replier_options import CreateInboxReplierOptions
from mailslurp_client.models.create_inbox_ruleset_options import CreateInboxRulesetOptions
from mailslurp_client.models.create_template_options import CreateTemplateOptions
from mailslurp_client.models.create_tracking_pixel_options import CreateTrackingPixelOptions
from mailslurp_client.models.create_webhook_options import CreateWebhookOptions
from mailslurp_client.models.dns_lookup_options import DNSLookupOptions
from mailslurp_client.models.dns_lookup_result import DNSLookupResult
from mailslurp_client.models.dns_lookup_results import DNSLookupResults
from mailslurp_client.models.dns_lookups_options import DNSLookupsOptions
from mailslurp_client.models.delivery_status_dto import DeliveryStatusDto
from mailslurp_client.models.describe_domain_options import DescribeDomainOptions
from mailslurp_client.models.describe_mail_server_domain_result import DescribeMailServerDomainResult
from mailslurp_client.models.domain_dto import DomainDto
from mailslurp_client.models.domain_group import DomainGroup
from mailslurp_client.models.domain_groups_dto import DomainGroupsDto
from mailslurp_client.models.domain_information import DomainInformation
from mailslurp_client.models.domain_issues_dto import DomainIssuesDto
from mailslurp_client.models.domain_name_record import DomainNameRecord
from mailslurp_client.models.domain_preview import DomainPreview
from mailslurp_client.models.download_attachment_dto import DownloadAttachmentDto
from mailslurp_client.models.email import Email
from mailslurp_client.models.email_analysis import EmailAnalysis
from mailslurp_client.models.email_available_result import EmailAvailableResult
from mailslurp_client.models.email_content_match_result import EmailContentMatchResult
from mailslurp_client.models.email_content_part_result import EmailContentPartResult
from mailslurp_client.models.email_feature_category_name import EmailFeatureCategoryName
from mailslurp_client.models.email_feature_family_name import EmailFeatureFamilyName
from mailslurp_client.models.email_feature_family_statistics import EmailFeatureFamilyStatistics
from mailslurp_client.models.email_feature_names import EmailFeatureNames
from mailslurp_client.models.email_feature_overview import EmailFeatureOverview
from mailslurp_client.models.email_feature_platform_name import EmailFeaturePlatformName
from mailslurp_client.models.email_feature_platform_statistics import EmailFeaturePlatformStatistics
from mailslurp_client.models.email_feature_support_flags import EmailFeatureSupportFlags
from mailslurp_client.models.email_feature_support_result import EmailFeatureSupportResult
from mailslurp_client.models.email_feature_support_status_percentage import EmailFeatureSupportStatusPercentage
from mailslurp_client.models.email_feature_version_statistics import EmailFeatureVersionStatistics
from mailslurp_client.models.email_html_dto import EmailHtmlDto
from mailslurp_client.models.email_links_result import EmailLinksResult
from mailslurp_client.models.email_preview import EmailPreview
from mailslurp_client.models.email_preview_urls import EmailPreviewUrls
from mailslurp_client.models.email_projection import EmailProjection
from mailslurp_client.models.email_recipients import EmailRecipients
from mailslurp_client.models.email_screenshot_result import EmailScreenshotResult
from mailslurp_client.models.email_text_lines_result import EmailTextLinesResult
from mailslurp_client.models.email_validation_request_dto import EmailValidationRequestDto
from mailslurp_client.models.email_verification_result import EmailVerificationResult
from mailslurp_client.models.emergency_address import EmergencyAddress
from mailslurp_client.models.emergency_address_dto import EmergencyAddressDto
from mailslurp_client.models.empty_response_dto import EmptyResponseDto
from mailslurp_client.models.expiration_defaults import ExpirationDefaults
from mailslurp_client.models.expired_inbox_dto import ExpiredInboxDto
from mailslurp_client.models.expired_inbox_record_projection import ExpiredInboxRecordProjection
from mailslurp_client.models.export_link import ExportLink
from mailslurp_client.models.export_options import ExportOptions
from mailslurp_client.models.fake_email_dto import FakeEmailDto
from mailslurp_client.models.fake_email_preview import FakeEmailPreview
from mailslurp_client.models.fake_email_result import FakeEmailResult
from mailslurp_client.models.filter_bounced_recipients_options import FilterBouncedRecipientsOptions
from mailslurp_client.models.filter_bounced_recipients_result import FilterBouncedRecipientsResult
from mailslurp_client.models.flush_expired_inboxes_result import FlushExpiredInboxesResult
from mailslurp_client.models.forward_email_options import ForwardEmailOptions
from mailslurp_client.models.generate_bimi_record_options import GenerateBimiRecordOptions
from mailslurp_client.models.generate_bimi_record_results import GenerateBimiRecordResults
from mailslurp_client.models.generate_dmarc_record_options import GenerateDmarcRecordOptions
from mailslurp_client.models.generate_dmarc_record_results import GenerateDmarcRecordResults
from mailslurp_client.models.generate_mta_sts_record_options import GenerateMtaStsRecordOptions
from mailslurp_client.models.generate_mta_sts_record_results import GenerateMtaStsRecordResults
from mailslurp_client.models.generate_tls_reporting_record_options import GenerateTlsReportingRecordOptions
from mailslurp_client.models.generate_tls_reporting_record_results import GenerateTlsReportingRecordResults
from mailslurp_client.models.get_email_screenshot_options import GetEmailScreenshotOptions
from mailslurp_client.models.gravatar_url import GravatarUrl
from mailslurp_client.models.group_contacts_dto import GroupContactsDto
from mailslurp_client.models.group_dto import GroupDto
from mailslurp_client.models.group_projection import GroupProjection
from mailslurp_client.models.html_validation_result import HTMLValidationResult
from mailslurp_client.models.ip_address_result import IPAddressResult
from mailslurp_client.models.image_issue import ImageIssue
from mailslurp_client.models.imap_access_details import ImapAccessDetails
from mailslurp_client.models.imap_email_projection import ImapEmailProjection
from mailslurp_client.models.imap_flag_operation_options import ImapFlagOperationOptions
from mailslurp_client.models.imap_mailbox_status import ImapMailboxStatus
from mailslurp_client.models.imap_server_fetch_item import ImapServerFetchItem
from mailslurp_client.models.imap_server_fetch_result import ImapServerFetchResult
from mailslurp_client.models.imap_server_get_result import ImapServerGetResult
from mailslurp_client.models.imap_server_list_options import ImapServerListOptions
from mailslurp_client.models.imap_server_list_result import ImapServerListResult
from mailslurp_client.models.imap_server_mailbox_result import ImapServerMailboxResult
from mailslurp_client.models.imap_server_search_options import ImapServerSearchOptions
from mailslurp_client.models.imap_server_search_result import ImapServerSearchResult
from mailslurp_client.models.imap_server_status_options import ImapServerStatusOptions
from mailslurp_client.models.imap_server_status_result import ImapServerStatusResult
from mailslurp_client.models.imap_smtp_access_details import ImapSmtpAccessDetails
from mailslurp_client.models.imap_smtp_access_servers import ImapSmtpAccessServers
from mailslurp_client.models.imap_update_flags_options import ImapUpdateFlagsOptions
from mailslurp_client.models.inbox_by_email_address_result import InboxByEmailAddressResult
from mailslurp_client.models.inbox_by_name_result import InboxByNameResult
from mailslurp_client.models.inbox_dto import InboxDto
from mailslurp_client.models.inbox_exists_dto import InboxExistsDto
from mailslurp_client.models.inbox_forwarder_dto import InboxForwarderDto
from mailslurp_client.models.inbox_forwarder_event_dto import InboxForwarderEventDto
from mailslurp_client.models.inbox_forwarder_event_projection import InboxForwarderEventProjection
from mailslurp_client.models.inbox_forwarder_test_options import InboxForwarderTestOptions
from mailslurp_client.models.inbox_forwarder_test_result import InboxForwarderTestResult
from mailslurp_client.models.inbox_id_item import InboxIdItem
from mailslurp_client.models.inbox_ids_result import InboxIdsResult
from mailslurp_client.models.inbox_preview import InboxPreview
from mailslurp_client.models.inbox_replier_dto import InboxReplierDto
from mailslurp_client.models.inbox_replier_event_projection import InboxReplierEventProjection
from mailslurp_client.models.inbox_ruleset_dto import InboxRulesetDto
from mailslurp_client.models.inbox_ruleset_test_options import InboxRulesetTestOptions
from mailslurp_client.models.inbox_ruleset_test_result import InboxRulesetTestResult
from mailslurp_client.models.inline_object import InlineObject
from mailslurp_client.models.json_schema_dto import JSONSchemaDto
from mailslurp_client.models.link_issue import LinkIssue
from mailslurp_client.models.list_unsubscribe_recipient_projection import ListUnsubscribeRecipientProjection
from mailslurp_client.models.lookup_bimi_domain_options import LookupBimiDomainOptions
from mailslurp_client.models.lookup_bimi_domain_results import LookupBimiDomainResults
from mailslurp_client.models.lookup_dmarc_domain_options import LookupDmarcDomainOptions
from mailslurp_client.models.lookup_dmarc_domain_results import LookupDmarcDomainResults
from mailslurp_client.models.lookup_mta_sts_domain_options import LookupMtaStsDomainOptions
from mailslurp_client.models.lookup_mta_sts_domain_results import LookupMtaStsDomainResults
from mailslurp_client.models.lookup_tls_reporting_domain_options import LookupTlsReportingDomainOptions
from mailslurp_client.models.lookup_tls_reporting_domain_results import LookupTlsReportingDomainResults
from mailslurp_client.models.match_option import MatchOption
from mailslurp_client.models.match_options import MatchOptions
from mailslurp_client.models.missed_email_dto import MissedEmailDto
from mailslurp_client.models.missed_email_projection import MissedEmailProjection
from mailslurp_client.models.name_server_record import NameServerRecord
from mailslurp_client.models.new_fake_email_address_result import NewFakeEmailAddressResult
from mailslurp_client.models.organization_inbox_projection import OrganizationInboxProjection
from mailslurp_client.models.page_alias import PageAlias
from mailslurp_client.models.page_attachment_entity import PageAttachmentEntity
from mailslurp_client.models.page_bounced_email import PageBouncedEmail
from mailslurp_client.models.page_bounced_recipients import PageBouncedRecipients
from mailslurp_client.models.page_complaint import PageComplaint
from mailslurp_client.models.page_connector import PageConnector
from mailslurp_client.models.page_connector_sync_events import PageConnectorSyncEvents
from mailslurp_client.models.page_contact_projection import PageContactProjection
from mailslurp_client.models.page_delivery_status import PageDeliveryStatus
from mailslurp_client.models.page_email_preview import PageEmailPreview
from mailslurp_client.models.page_email_projection import PageEmailProjection
from mailslurp_client.models.page_email_validation_request import PageEmailValidationRequest
from mailslurp_client.models.page_expired_inbox_record_projection import PageExpiredInboxRecordProjection
from mailslurp_client.models.page_group_projection import PageGroupProjection
from mailslurp_client.models.page_inbox_forwarder_dto import PageInboxForwarderDto
from mailslurp_client.models.page_inbox_forwarder_events import PageInboxForwarderEvents
from mailslurp_client.models.page_inbox_projection import PageInboxProjection
from mailslurp_client.models.page_inbox_replier_dto import PageInboxReplierDto
from mailslurp_client.models.page_inbox_replier_events import PageInboxReplierEvents
from mailslurp_client.models.page_inbox_ruleset_dto import PageInboxRulesetDto
from mailslurp_client.models.page_list_unsubscribe_recipients import PageListUnsubscribeRecipients
from mailslurp_client.models.page_missed_email_projection import PageMissedEmailProjection
from mailslurp_client.models.page_organization_inbox_projection import PageOrganizationInboxProjection
from mailslurp_client.models.page_phone_number_projection import PagePhoneNumberProjection
from mailslurp_client.models.page_scheduled_jobs import PageScheduledJobs
from mailslurp_client.models.page_sent_email_projection import PageSentEmailProjection
from mailslurp_client.models.page_sent_email_with_queue_projection import PageSentEmailWithQueueProjection
from mailslurp_client.models.page_sms_projection import PageSmsProjection
from mailslurp_client.models.page_template_projection import PageTemplateProjection
from mailslurp_client.models.page_thread_projection import PageThreadProjection
from mailslurp_client.models.page_tracking_pixel_projection import PageTrackingPixelProjection
from mailslurp_client.models.page_unknown_missed_email_projection import PageUnknownMissedEmailProjection
from mailslurp_client.models.page_webhook_projection import PageWebhookProjection
from mailslurp_client.models.page_webhook_result import PageWebhookResult
from mailslurp_client.models.pageable_object import PageableObject
from mailslurp_client.models.phone_number_dto import PhoneNumberDto
from mailslurp_client.models.phone_number_projection import PhoneNumberProjection
from mailslurp_client.models.phone_plan_dto import PhonePlanDto
from mailslurp_client.models.raw_email_json import RawEmailJson
from mailslurp_client.models.recipient import Recipient
from mailslurp_client.models.reply_for_sms import ReplyForSms
from mailslurp_client.models.reply_to_alias_email_options import ReplyToAliasEmailOptions
from mailslurp_client.models.reply_to_email_options import ReplyToEmailOptions
from mailslurp_client.models.scheduled_job import ScheduledJob
from mailslurp_client.models.scheduled_job_dto import ScheduledJobDto
from mailslurp_client.models.search_emails_options import SearchEmailsOptions
from mailslurp_client.models.search_inboxes_options import SearchInboxesOptions
from mailslurp_client.models.send_email_body_part import SendEmailBodyPart
from mailslurp_client.models.send_email_options import SendEmailOptions
from mailslurp_client.models.send_smtp_envelope_options import SendSMTPEnvelopeOptions
from mailslurp_client.models.send_with_queue_result import SendWithQueueResult
from mailslurp_client.models.sender import Sender
from mailslurp_client.models.sent_email_dto import SentEmailDto
from mailslurp_client.models.sent_email_projection import SentEmailProjection
from mailslurp_client.models.sent_sms_dto import SentSmsDto
from mailslurp_client.models.server_endpoints import ServerEndpoints
from mailslurp_client.models.set_inbox_favourited_options import SetInboxFavouritedOptions
from mailslurp_client.models.simple_send_email_options import SimpleSendEmailOptions
from mailslurp_client.models.sms_dto import SmsDto
from mailslurp_client.models.sms_match_option import SmsMatchOption
from mailslurp_client.models.sms_preview import SmsPreview
from mailslurp_client.models.sms_projection import SmsProjection
from mailslurp_client.models.sms_reply_options import SmsReplyOptions
from mailslurp_client.models.smtp_access_details import SmtpAccessDetails
from mailslurp_client.models.sort_object import SortObject
from mailslurp_client.models.spelling_issue import SpellingIssue
from mailslurp_client.models.template_dto import TemplateDto
from mailslurp_client.models.template_preview import TemplatePreview
from mailslurp_client.models.template_projection import TemplateProjection
from mailslurp_client.models.template_variable import TemplateVariable
from mailslurp_client.models.test_inbox_ruleset_receiving_options import TestInboxRulesetReceivingOptions
from mailslurp_client.models.test_inbox_ruleset_receiving_result import TestInboxRulesetReceivingResult
from mailslurp_client.models.test_inbox_ruleset_sending_options import TestInboxRulesetSendingOptions
from mailslurp_client.models.test_inbox_ruleset_sending_result import TestInboxRulesetSendingResult
from mailslurp_client.models.test_new_inbox_forwarder_options import TestNewInboxForwarderOptions
from mailslurp_client.models.test_new_inbox_ruleset_options import TestNewInboxRulesetOptions
from mailslurp_client.models.test_phone_number_options import TestPhoneNumberOptions
from mailslurp_client.models.thread_projection import ThreadProjection
from mailslurp_client.models.tracking_pixel_dto import TrackingPixelDto
from mailslurp_client.models.tracking_pixel_projection import TrackingPixelProjection
from mailslurp_client.models.unknown_missed_email_projection import UnknownMissedEmailProjection
from mailslurp_client.models.unread_count import UnreadCount
from mailslurp_client.models.unseen_error_count_dto import UnseenErrorCountDto
from mailslurp_client.models.update_alias_options import UpdateAliasOptions
from mailslurp_client.models.update_domain_options import UpdateDomainOptions
from mailslurp_client.models.update_group_contacts import UpdateGroupContacts
from mailslurp_client.models.update_imap_access_options import UpdateImapAccessOptions
from mailslurp_client.models.update_inbox_options import UpdateInboxOptions
from mailslurp_client.models.update_inbox_replier_options import UpdateInboxReplierOptions
from mailslurp_client.models.update_smtp_access_options import UpdateSmtpAccessOptions
from mailslurp_client.models.upload_attachment_options import UploadAttachmentOptions
from mailslurp_client.models.user_info_dto import UserInfoDto
from mailslurp_client.models.validate_email_address_list_options import ValidateEmailAddressListOptions
from mailslurp_client.models.validate_email_address_list_result import ValidateEmailAddressListResult
from mailslurp_client.models.validation_dto import ValidationDto
from mailslurp_client.models.validation_message import ValidationMessage
from mailslurp_client.models.verify_email_address_options import VerifyEmailAddressOptions
from mailslurp_client.models.verify_webhook_signature_options import VerifyWebhookSignatureOptions
from mailslurp_client.models.verify_webhook_signature_results import VerifyWebhookSignatureResults
from mailslurp_client.models.wait_for_conditions import WaitForConditions
from mailslurp_client.models.wait_for_single_sms_options import WaitForSingleSmsOptions
from mailslurp_client.models.wait_for_sms_conditions import WaitForSmsConditions
from mailslurp_client.models.webhook_bounce_payload import WebhookBouncePayload
from mailslurp_client.models.webhook_bounce_recipient_payload import WebhookBounceRecipientPayload
from mailslurp_client.models.webhook_delivery_status_payload import WebhookDeliveryStatusPayload
from mailslurp_client.models.webhook_dto import WebhookDto
from mailslurp_client.models.webhook_email_opened_payload import WebhookEmailOpenedPayload
from mailslurp_client.models.webhook_email_read_payload import WebhookEmailReadPayload
from mailslurp_client.models.webhook_header_name_value import WebhookHeaderNameValue
from mailslurp_client.models.webhook_headers import WebhookHeaders
from mailslurp_client.models.webhook_new_attachment_payload import WebhookNewAttachmentPayload
from mailslurp_client.models.webhook_new_contact_payload import WebhookNewContactPayload
from mailslurp_client.models.webhook_new_email_payload import WebhookNewEmailPayload
from mailslurp_client.models.webhook_new_sms_payload import WebhookNewSmsPayload
from mailslurp_client.models.webhook_projection import WebhookProjection
from mailslurp_client.models.webhook_redrive_all_result import WebhookRedriveAllResult
from mailslurp_client.models.webhook_redrive_result import WebhookRedriveResult
from mailslurp_client.models.webhook_result_dto import WebhookResultDto
from mailslurp_client.models.webhook_test_request import WebhookTestRequest
from mailslurp_client.models.webhook_test_response import WebhookTestResponse
from mailslurp_client.models.webhook_test_result import WebhookTestResult

mailslurp_client/api/webhook_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class WebhookControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def create_account_webhook(self, create_webhook_options, **kwargs):  # noqa: E501
        """Attach a WebHook URL to an inbox  # noqa: E501

        Get notified of account level events such as bounce and bounce recipient.  # 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_account_webhook(create_webhook_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateWebhookOptions create_webhook_options: (required)
        :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: WebhookDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_account_webhook_with_http_info(create_webhook_options, **kwargs)  # noqa: E501

    def create_account_webhook_with_http_info(self, create_webhook_options, **kwargs):  # noqa: E501
        """Attach a WebHook URL to an inbox  # noqa: E501

        Get notified of account level events such as bounce and bounce recipient.  # 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_account_webhook_with_http_info(create_webhook_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateWebhookOptions create_webhook_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(WebhookDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_webhook_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_account_webhook" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'create_webhook_options' is set
        if self.api_client.client_side_validation and ('create_webhook_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_webhook_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_webhook_options` when calling `create_account_webhook`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_webhook_options' in local_var_params:
            body_params = local_var_params['create_webhook_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(
            '/webhooks', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookDto',  # 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_webhook(self, inbox_id, create_webhook_options, **kwargs):  # noqa: E501
        """Attach a WebHook URL to an inbox  # noqa: E501

        Get notified whenever an inbox receives an email via a WebHook URL. An emailID will be posted to this URL every time an email is received for this inbox. The URL must be publicly reachable by the MailSlurp server. You can provide basicAuth values if you wish to secure this endpoint.  # 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_webhook(inbox_id, create_webhook_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param CreateWebhookOptions create_webhook_options: (required)
        :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: WebhookDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_webhook_with_http_info(inbox_id, create_webhook_options, **kwargs)  # noqa: E501

    def create_webhook_with_http_info(self, inbox_id, create_webhook_options, **kwargs):  # noqa: E501
        """Attach a WebHook URL to an inbox  # noqa: E501

        Get notified whenever an inbox receives an email via a WebHook URL. An emailID will be posted to this URL every time an email is received for this inbox. The URL must be publicly reachable by the MailSlurp server. You can provide basicAuth values if you wish to secure this endpoint.  # 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_webhook_with_http_info(inbox_id, create_webhook_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param CreateWebhookOptions create_webhook_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(WebhookDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'create_webhook_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_webhook" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `create_webhook`")  # noqa: E501
        # verify the required parameter 'create_webhook_options' is set
        if self.api_client.client_side_validation and ('create_webhook_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_webhook_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_webhook_options` when calling `create_webhook`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_webhook_options' in local_var_params:
            body_params = local_var_params['create_webhook_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(
            '/inboxes/{inboxId}/webhooks', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookDto',  # 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_webhook_for_phone_number(self, phone_number_id, create_webhook_options, **kwargs):  # noqa: E501
        """Attach a WebHook URL to a phone number  # noqa: E501

        Get notified whenever a phone number receives an SMS via a WebHook URL.  # 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_webhook_for_phone_number(phone_number_id, create_webhook_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param CreateWebhookOptions create_webhook_options: (required)
        :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: WebhookDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_webhook_for_phone_number_with_http_info(phone_number_id, create_webhook_options, **kwargs)  # noqa: E501

    def create_webhook_for_phone_number_with_http_info(self, phone_number_id, create_webhook_options, **kwargs):  # noqa: E501
        """Attach a WebHook URL to a phone number  # noqa: E501

        Get notified whenever a phone number receives an SMS via a WebHook URL.  # 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_webhook_for_phone_number_with_http_info(phone_number_id, create_webhook_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param CreateWebhookOptions create_webhook_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(WebhookDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'phone_number_id',
            'create_webhook_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_webhook_for_phone_number" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'phone_number_id' is set
        if self.api_client.client_side_validation and ('phone_number_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['phone_number_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `phone_number_id` when calling `create_webhook_for_phone_number`")  # noqa: E501
        # verify the required parameter 'create_webhook_options' is set
        if self.api_client.client_side_validation and ('create_webhook_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_webhook_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_webhook_options` when calling `create_webhook_for_phone_number`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'phone_number_id' in local_var_params:
            path_params['phoneNumberId'] = local_var_params['phone_number_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_webhook_options' in local_var_params:
            body_params = local_var_params['create_webhook_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(
            '/phone/numbers/{phoneNumberId}/webhooks', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookDto',  # 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_all_webhooks(self, **kwargs):  # noqa: E501
        """Delete all webhooks  # 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_all_webhooks(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param datetime before: before
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_all_webhooks_with_http_info(**kwargs)  # noqa: E501

    def delete_all_webhooks_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all webhooks  # 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_all_webhooks_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param datetime before: before
        :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 = [
            '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 delete_all_webhooks" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks', '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 delete_webhook(self, inbox_id, webhook_id, **kwargs):  # noqa: E501
        """Delete and disable a Webhook for 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.delete_webhook(inbox_id, webhook_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param str webhook_id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_webhook_with_http_info(inbox_id, webhook_id, **kwargs)  # noqa: E501

    def delete_webhook_with_http_info(self, inbox_id, webhook_id, **kwargs):  # noqa: E501
        """Delete and disable a Webhook for 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.delete_webhook_with_http_info(inbox_id, webhook_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param str webhook_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 = [
            'inbox_id',
            'webhook_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_webhook" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `delete_webhook`")  # noqa: E501
        # verify the required parameter 'webhook_id' is set
        if self.api_client.client_side_validation and ('webhook_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['webhook_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `webhook_id` when calling `delete_webhook`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501
        if 'webhook_id' in local_var_params:
            path_params['webhookId'] = local_var_params['webhook_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(
            '/inboxes/{inboxId}/webhooks/{webhookId}', '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 delete_webhook_by_id(self, webhook_id, **kwargs):  # noqa: E501
        """Delete a webhook  # 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_webhook_by_id(webhook_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_webhook_by_id_with_http_info(webhook_id, **kwargs)  # noqa: E501

    def delete_webhook_by_id_with_http_info(self, webhook_id, **kwargs):  # noqa: E501
        """Delete a webhook  # 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_webhook_by_id_with_http_info(webhook_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_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 = [
            'webhook_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_webhook_by_id" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'webhook_id' is set
        if self.api_client.client_side_validation and ('webhook_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['webhook_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `webhook_id` when calling `delete_webhook_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'webhook_id' in local_var_params:
            path_params['webhookId'] = local_var_params['webhook_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(
            '/webhooks/{webhookId}', '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_all_account_webhooks(self, **kwargs):  # noqa: E501
        """List account webhooks Paginated  # noqa: E501

        List account webhooks in paginated form. Allows for page index, page size, and sort direction.  # 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_all_account_webhooks(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 event_type: Optional event type
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageWebhookProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_all_account_webhooks_with_http_info(**kwargs)  # noqa: E501

    def get_all_account_webhooks_with_http_info(self, **kwargs):  # noqa: E501
        """List account webhooks Paginated  # noqa: E501

        List account webhooks in paginated form. Allows for page index, page size, and sort direction.  # 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_all_account_webhooks_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 event_type: Optional event type
        :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(PageWebhookProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            'event_type',
            '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 get_all_account_webhooks" % 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_all_account_webhooks`, 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_all_account_webhooks`, 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_all_account_webhooks`, 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_all_account_webhooks`, 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 'event_type' in local_var_params and local_var_params['event_type'] is not None:  # noqa: E501
            query_params.append(('eventType', local_var_params['event_type']))  # 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(
            '/webhooks/account/paginated', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageWebhookProjection',  # 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_all_webhook_results(self, **kwargs):  # noqa: E501
        """Get results for all webhooks  # 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_all_webhook_results(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 in list pagination
        :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 unseen_only: Filter for unseen exceptions only
        :param str result_type: Filter by result type
        :param str event_name: Filter by event name
        :param int min_status_code: Minimum response status
        :param int max_status_code: Maximum response status
        :param str inbox_id: Inbox ID
        :param str sms_id: Sms ID
        :param str attachment_id: Attachment ID
        :param str email_id: Email ID
        :param str phone_id: Phone ID
        :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: PageWebhookResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_all_webhook_results_with_http_info(**kwargs)  # noqa: E501

    def get_all_webhook_results_with_http_info(self, **kwargs):  # noqa: E501
        """Get results for all webhooks  # 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_all_webhook_results_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 in list pagination
        :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 unseen_only: Filter for unseen exceptions only
        :param str result_type: Filter by result type
        :param str event_name: Filter by event name
        :param int min_status_code: Minimum response status
        :param int max_status_code: Maximum response status
        :param str inbox_id: Inbox ID
        :param str sms_id: Sms ID
        :param str attachment_id: Attachment ID
        :param str email_id: Email ID
        :param str phone_id: Phone ID
        :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(PageWebhookResult, 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',
            'unseen_only',
            'result_type',
            'event_name',
            'min_status_code',
            'max_status_code',
            'inbox_id',
            'sms_id',
            'attachment_id',
            'email_id',
            'phone_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_all_webhook_results" % 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
        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 'unseen_only' in local_var_params and local_var_params['unseen_only'] is not None:  # noqa: E501
            query_params.append(('unseenOnly', local_var_params['unseen_only']))  # noqa: E501
        if 'result_type' in local_var_params and local_var_params['result_type'] is not None:  # noqa: E501
            query_params.append(('resultType', local_var_params['result_type']))  # noqa: E501
        if 'event_name' in local_var_params and local_var_params['event_name'] is not None:  # noqa: E501
            query_params.append(('eventName', local_var_params['event_name']))  # noqa: E501
        if 'min_status_code' in local_var_params and local_var_params['min_status_code'] is not None:  # noqa: E501
            query_params.append(('minStatusCode', local_var_params['min_status_code']))  # noqa: E501
        if 'max_status_code' in local_var_params and local_var_params['max_status_code'] is not None:  # noqa: E501
            query_params.append(('maxStatusCode', local_var_params['max_status_code']))  # 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 'sms_id' in local_var_params and local_var_params['sms_id'] is not None:  # noqa: E501
            query_params.append(('smsId', local_var_params['sms_id']))  # noqa: E501
        if 'attachment_id' in local_var_params and local_var_params['attachment_id'] is not None:  # noqa: E501
            query_params.append(('attachmentId', local_var_params['attachment_id']))  # noqa: E501
        if 'email_id' in local_var_params and local_var_params['email_id'] is not None:  # noqa: E501
            query_params.append(('emailId', local_var_params['email_id']))  # noqa: E501
        if 'phone_id' in local_var_params and local_var_params['phone_id'] is not None:  # noqa: E501
            query_params.append(('phoneId', local_var_params['phone_id']))  # 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(
            '/webhooks/results', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageWebhookResult',  # 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_all_webhooks(self, **kwargs):  # noqa: E501
        """List Webhooks Paginated  # noqa: E501

        List webhooks in paginated form. Allows for page index, page size, and sort direction.  # 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_all_webhooks(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 str inbox_id: Filter by inboxId
        :param str phone_id: Filter by phoneId
        :param datetime before: Filter by created at before the given timestamp
        :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: PageWebhookProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_all_webhooks_with_http_info(**kwargs)  # noqa: E501

    def get_all_webhooks_with_http_info(self, **kwargs):  # noqa: E501
        """List Webhooks Paginated  # noqa: E501

        List webhooks in paginated form. Allows for page index, page size, and sort direction.  # 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_all_webhooks_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 str inbox_id: Filter by inboxId
        :param str phone_id: Filter by phoneId
        :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(PageWebhookProjection, 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',
            'inbox_id',
            'phone_id',
            '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 get_all_webhooks" % 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_all_webhooks`, 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_all_webhooks`, 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_all_webhooks`, 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_all_webhooks`, 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 '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 'phone_id' in local_var_params and local_var_params['phone_id'] is not None:  # noqa: E501
            query_params.append(('phoneId', local_var_params['phone_id']))  # 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(
            '/webhooks/paginated', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageWebhookProjection',  # 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_webhooks_paginated(self, inbox_id, **kwargs):  # noqa: E501
        """Get paginated webhooks for 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_webhooks_paginated(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param int page: Optional page index in list pagination
        :param int size: Optional page size in list pagination
        :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 _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: PageWebhookProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_webhooks_paginated_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def get_inbox_webhooks_paginated_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """Get paginated webhooks for 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_webhooks_paginated_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param int page: Optional page index in list pagination
        :param int size: Optional page size in list pagination
        :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 _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(PageWebhookProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort',
            'search_filter',
            '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 get_inbox_webhooks_paginated" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `get_inbox_webhooks_paginated`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_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
        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

        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(
            '/inboxes/{inboxId}/webhooks/paginated', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageWebhookProjection',  # 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_json_schema_for_webhook_event(self, event, **kwargs):  # noqa: E501
        """get_json_schema_for_webhook_event  # noqa: E501

        Get JSON Schema definition for webhook payload by event  # 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_json_schema_for_webhook_event(event, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str event: (required)
        :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: JSONSchemaDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_json_schema_for_webhook_event_with_http_info(event, **kwargs)  # noqa: E501

    def get_json_schema_for_webhook_event_with_http_info(self, event, **kwargs):  # noqa: E501
        """get_json_schema_for_webhook_event  # noqa: E501

        Get JSON Schema definition for webhook payload by event  # 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_json_schema_for_webhook_event_with_http_info(event, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str event: (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(JSONSchemaDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'event'
        ]
        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_json_schema_for_webhook_event" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'event' is set
        if self.api_client.client_side_validation and ('event' not in local_var_params or  # noqa: E501
                                                        local_var_params['event'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `event` when calling `get_json_schema_for_webhook_event`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'event' in local_var_params and local_var_params['event'] is not None:  # noqa: E501
            query_params.append(('event', local_var_params['event']))  # 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(
            '/webhooks/schema', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='JSONSchemaDto',  # 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_json_schema_for_webhook_payload(self, webhook_id, **kwargs):  # noqa: E501
        """get_json_schema_for_webhook_payload  # noqa: E501

        Get JSON Schema definition for webhook payload  # 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_json_schema_for_webhook_payload(webhook_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_id: (required)
        :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: JSONSchemaDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_json_schema_for_webhook_payload_with_http_info(webhook_id, **kwargs)  # noqa: E501

    def get_json_schema_for_webhook_payload_with_http_info(self, webhook_id, **kwargs):  # noqa: E501
        """get_json_schema_for_webhook_payload  # noqa: E501

        Get JSON Schema definition for webhook payload  # 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_json_schema_for_webhook_payload_with_http_info(webhook_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_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: tuple(JSONSchemaDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'webhook_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_json_schema_for_webhook_payload" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'webhook_id' is set
        if self.api_client.client_side_validation and ('webhook_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['webhook_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `webhook_id` when calling `get_json_schema_for_webhook_payload`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'webhook_id' in local_var_params:
            path_params['webhookId'] = local_var_params['webhook_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/{webhookId}/schema', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='JSONSchemaDto',  # 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_phone_number_webhooks_paginated(self, phone_id, **kwargs):  # noqa: E501
        """Get paginated webhooks for a phone number  # 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_phone_number_webhooks_paginated(phone_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_id: (required)
        :param int page: Optional page index in list pagination
        :param int size: Optional page size in list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageWebhookProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_phone_number_webhooks_paginated_with_http_info(phone_id, **kwargs)  # noqa: E501

    def get_phone_number_webhooks_paginated_with_http_info(self, phone_id, **kwargs):  # noqa: E501
        """Get paginated webhooks for a phone number  # 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_phone_number_webhooks_paginated_with_http_info(phone_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_id: (required)
        :param int page: Optional page index in list pagination
        :param int size: Optional page size in list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PageWebhookProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'phone_id',
            'page',
            'size',
            'sort',
            '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 get_phone_number_webhooks_paginated" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'phone_id' is set
        if self.api_client.client_side_validation and ('phone_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['phone_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `phone_id` when calling `get_phone_number_webhooks_paginated`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'phone_id' in local_var_params:
            path_params['phoneId'] = local_var_params['phone_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
        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(
            '/phone/numbers/{phoneId}/webhooks/paginated', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageWebhookProjection',  # 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_test_webhook_payload(self, **kwargs):  # noqa: E501
        """get_test_webhook_payload  # noqa: E501

        Get test webhook payload example. Response content depends on eventName passed. Uses `EMAIL_RECEIVED` as default.  # 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_test_webhook_payload(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str event_name:
        :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: AbstractWebhookPayload
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_test_webhook_payload_with_http_info(**kwargs)  # noqa: E501

    def get_test_webhook_payload_with_http_info(self, **kwargs):  # noqa: E501
        """get_test_webhook_payload  # noqa: E501

        Get test webhook payload example. Response content depends on eventName passed. Uses `EMAIL_RECEIVED` as default.  # 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_test_webhook_payload_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str event_name:
        :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(AbstractWebhookPayload, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'event_name'
        ]
        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_test_webhook_payload" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'event_name' in local_var_params and local_var_params['event_name'] is not None:  # noqa: E501
            query_params.append(('eventName', local_var_params['event_name']))  # 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(
            '/webhooks/test', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AbstractWebhookPayload',  # 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_test_webhook_payload_bounce(self, **kwargs):  # noqa: E501
        """get_test_webhook_payload_bounce  # noqa: E501

        Get webhook test payload for bounce  # 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_test_webhook_payload_bounce(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: WebhookBouncePayload
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_test_webhook_payload_bounce_with_http_info(**kwargs)  # noqa: E501

    def get_test_webhook_payload_bounce_with_http_info(self, **kwargs):  # noqa: E501
        """get_test_webhook_payload_bounce  # noqa: E501

        Get webhook test payload for bounce  # 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_test_webhook_payload_bounce_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(WebhookBouncePayload, 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_test_webhook_payload_bounce" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/test/email-bounce-payload', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookBouncePayload',  # 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_test_webhook_payload_bounce_recipient(self, **kwargs):  # noqa: E501
        """get_test_webhook_payload_bounce_recipient  # noqa: E501

        Get webhook test payload for bounce recipient  # 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_test_webhook_payload_bounce_recipient(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: WebhookBounceRecipientPayload
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_test_webhook_payload_bounce_recipient_with_http_info(**kwargs)  # noqa: E501

    def get_test_webhook_payload_bounce_recipient_with_http_info(self, **kwargs):  # noqa: E501
        """get_test_webhook_payload_bounce_recipient  # noqa: E501

        Get webhook test payload for bounce recipient  # 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_test_webhook_payload_bounce_recipient_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(WebhookBounceRecipientPayload, 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_test_webhook_payload_bounce_recipient" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/test/email-bounce-recipient-payload', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookBounceRecipientPayload',  # 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_test_webhook_payload_delivery_status(self, **kwargs):  # noqa: E501
        """Get webhook test payload for delivery status event  # 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_test_webhook_payload_delivery_status(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: WebhookDeliveryStatusPayload
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_test_webhook_payload_delivery_status_with_http_info(**kwargs)  # noqa: E501

    def get_test_webhook_payload_delivery_status_with_http_info(self, **kwargs):  # noqa: E501
        """Get webhook test payload for delivery status event  # 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_test_webhook_payload_delivery_status_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(WebhookDeliveryStatusPayload, 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_test_webhook_payload_delivery_status" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/test/delivery-status-payload', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookDeliveryStatusPayload',  # 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_test_webhook_payload_email_opened(self, **kwargs):  # noqa: E501
        """get_test_webhook_payload_email_opened  # noqa: E501

        Get webhook test payload for email opened event  # 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_test_webhook_payload_email_opened(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: WebhookEmailOpenedPayload
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_test_webhook_payload_email_opened_with_http_info(**kwargs)  # noqa: E501

    def get_test_webhook_payload_email_opened_with_http_info(self, **kwargs):  # noqa: E501
        """get_test_webhook_payload_email_opened  # noqa: E501

        Get webhook test payload for email opened event  # 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_test_webhook_payload_email_opened_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(WebhookEmailOpenedPayload, 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_test_webhook_payload_email_opened" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/test/email-opened-payload', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookEmailOpenedPayload',  # 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_test_webhook_payload_email_read(self, **kwargs):  # noqa: E501
        """get_test_webhook_payload_email_read  # noqa: E501

        Get webhook test payload for email opened event  # 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_test_webhook_payload_email_read(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: WebhookEmailReadPayload
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_test_webhook_payload_email_read_with_http_info(**kwargs)  # noqa: E501

    def get_test_webhook_payload_email_read_with_http_info(self, **kwargs):  # noqa: E501
        """get_test_webhook_payload_email_read  # noqa: E501

        Get webhook test payload for email opened event  # 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_test_webhook_payload_email_read_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(WebhookEmailReadPayload, 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_test_webhook_payload_email_read" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/test/email-read-payload', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookEmailReadPayload',  # 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_test_webhook_payload_for_webhook(self, webhook_id, **kwargs):  # noqa: E501
        """get_test_webhook_payload_for_webhook  # noqa: E501

        Get example payload for webhook  # 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_test_webhook_payload_for_webhook(webhook_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_id: (required)
        :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: AbstractWebhookPayload
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_test_webhook_payload_for_webhook_with_http_info(webhook_id, **kwargs)  # noqa: E501

    def get_test_webhook_payload_for_webhook_with_http_info(self, webhook_id, **kwargs):  # noqa: E501
        """get_test_webhook_payload_for_webhook  # noqa: E501

        Get example payload for webhook  # 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_test_webhook_payload_for_webhook_with_http_info(webhook_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_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: tuple(AbstractWebhookPayload, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'webhook_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_test_webhook_payload_for_webhook" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'webhook_id' is set
        if self.api_client.client_side_validation and ('webhook_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['webhook_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `webhook_id` when calling `get_test_webhook_payload_for_webhook`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'webhook_id' in local_var_params:
            path_params['webhookId'] = local_var_params['webhook_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/{webhookId}/example', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AbstractWebhookPayload',  # 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_test_webhook_payload_new_attachment(self, **kwargs):  # noqa: E501
        """Get webhook test payload for new attachment event  # 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_test_webhook_payload_new_attachment(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: WebhookNewAttachmentPayload
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_test_webhook_payload_new_attachment_with_http_info(**kwargs)  # noqa: E501

    def get_test_webhook_payload_new_attachment_with_http_info(self, **kwargs):  # noqa: E501
        """Get webhook test payload for new attachment event  # 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_test_webhook_payload_new_attachment_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(WebhookNewAttachmentPayload, 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_test_webhook_payload_new_attachment" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/test/new-attachment-payload', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookNewAttachmentPayload',  # 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_test_webhook_payload_new_contact(self, **kwargs):  # noqa: E501
        """Get webhook test payload for new contact event  # 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_test_webhook_payload_new_contact(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: WebhookNewContactPayload
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_test_webhook_payload_new_contact_with_http_info(**kwargs)  # noqa: E501

    def get_test_webhook_payload_new_contact_with_http_info(self, **kwargs):  # noqa: E501
        """Get webhook test payload for new contact event  # 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_test_webhook_payload_new_contact_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(WebhookNewContactPayload, 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_test_webhook_payload_new_contact" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/test/new-contact-payload', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookNewContactPayload',  # 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_test_webhook_payload_new_email(self, **kwargs):  # noqa: E501
        """Get webhook test payload for new email event  # 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_test_webhook_payload_new_email(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: WebhookNewEmailPayload
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_test_webhook_payload_new_email_with_http_info(**kwargs)  # noqa: E501

    def get_test_webhook_payload_new_email_with_http_info(self, **kwargs):  # noqa: E501
        """Get webhook test payload for new email event  # 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_test_webhook_payload_new_email_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(WebhookNewEmailPayload, 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_test_webhook_payload_new_email" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/test/new-email-payload', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookNewEmailPayload',  # 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_test_webhook_payload_new_sms(self, **kwargs):  # noqa: E501
        """Get webhook test payload for new sms event  # 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_test_webhook_payload_new_sms(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: WebhookNewSmsPayload
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_test_webhook_payload_new_sms_with_http_info(**kwargs)  # noqa: E501

    def get_test_webhook_payload_new_sms_with_http_info(self, **kwargs):  # noqa: E501
        """Get webhook test payload for new sms event  # 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_test_webhook_payload_new_sms_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(WebhookNewSmsPayload, 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_test_webhook_payload_new_sms" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/test/new-sms-payload', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookNewSmsPayload',  # 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_webhook(self, webhook_id, **kwargs):  # noqa: E501
        """Get a webhook  # 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_webhook(webhook_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_id: (required)
        :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: WebhookDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_webhook_with_http_info(webhook_id, **kwargs)  # noqa: E501

    def get_webhook_with_http_info(self, webhook_id, **kwargs):  # noqa: E501
        """Get a webhook  # 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_webhook_with_http_info(webhook_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_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: tuple(WebhookDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'webhook_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_webhook" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'webhook_id' is set
        if self.api_client.client_side_validation and ('webhook_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['webhook_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `webhook_id` when calling `get_webhook`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'webhook_id' in local_var_params:
            path_params['webhookId'] = local_var_params['webhook_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/{webhookId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookDto',  # 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_webhook_result(self, webhook_result_id, **kwargs):  # noqa: E501
        """Get a webhook result for a webhook  # 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_webhook_result(webhook_result_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_result_id: Webhook Result ID (required)
        :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: WebhookResultDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_webhook_result_with_http_info(webhook_result_id, **kwargs)  # noqa: E501

    def get_webhook_result_with_http_info(self, webhook_result_id, **kwargs):  # noqa: E501
        """Get a webhook result for a webhook  # 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_webhook_result_with_http_info(webhook_result_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_result_id: Webhook Result 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: tuple(WebhookResultDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'webhook_result_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_webhook_result" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'webhook_result_id' is set
        if self.api_client.client_side_validation and ('webhook_result_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['webhook_result_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `webhook_result_id` when calling `get_webhook_result`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'webhook_result_id' in local_var_params:
            path_params['webhookResultId'] = local_var_params['webhook_result_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/results/{webhookResultId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookResultDto',  # 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_webhook_results(self, webhook_id, **kwargs):  # noqa: E501
        """Get a webhook results for a webhook  # 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_webhook_results(webhook_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_id: ID of webhook to get results for (required)
        :param int page: Optional page index in list pagination
        :param int size: Optional page size in list pagination
        :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 unseen_only: Filter for unseen exceptions only
        :param str result_type: Filter by result type
        :param str event_name: Filter by event name
        :param int min_status_code: Minimum response status
        :param int max_status_code: Maximum response status
        :param str inbox_id: Inbox ID
        :param str sms_id: Sms ID
        :param str attachment_id: Attachment ID
        :param str email_id: Email ID
        :param str phone_id: Phone ID
        :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: PageWebhookResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_webhook_results_with_http_info(webhook_id, **kwargs)  # noqa: E501

    def get_webhook_results_with_http_info(self, webhook_id, **kwargs):  # noqa: E501
        """Get a webhook results for a webhook  # 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_webhook_results_with_http_info(webhook_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_id: ID of webhook to get results for (required)
        :param int page: Optional page index in list pagination
        :param int size: Optional page size in list pagination
        :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 unseen_only: Filter for unseen exceptions only
        :param str result_type: Filter by result type
        :param str event_name: Filter by event name
        :param int min_status_code: Minimum response status
        :param int max_status_code: Maximum response status
        :param str inbox_id: Inbox ID
        :param str sms_id: Sms ID
        :param str attachment_id: Attachment ID
        :param str email_id: Email ID
        :param str phone_id: Phone ID
        :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(PageWebhookResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'webhook_id',
            'page',
            'size',
            'sort',
            'search_filter',
            'since',
            'before',
            'unseen_only',
            'result_type',
            'event_name',
            'min_status_code',
            'max_status_code',
            'inbox_id',
            'sms_id',
            'attachment_id',
            'email_id',
            'phone_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_webhook_results" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'webhook_id' is set
        if self.api_client.client_side_validation and ('webhook_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['webhook_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `webhook_id` when calling `get_webhook_results`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'webhook_id' in local_var_params:
            path_params['webhookId'] = local_var_params['webhook_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
        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 'unseen_only' in local_var_params and local_var_params['unseen_only'] is not None:  # noqa: E501
            query_params.append(('unseenOnly', local_var_params['unseen_only']))  # noqa: E501
        if 'result_type' in local_var_params and local_var_params['result_type'] is not None:  # noqa: E501
            query_params.append(('resultType', local_var_params['result_type']))  # noqa: E501
        if 'event_name' in local_var_params and local_var_params['event_name'] is not None:  # noqa: E501
            query_params.append(('eventName', local_var_params['event_name']))  # noqa: E501
        if 'min_status_code' in local_var_params and local_var_params['min_status_code'] is not None:  # noqa: E501
            query_params.append(('minStatusCode', local_var_params['min_status_code']))  # noqa: E501
        if 'max_status_code' in local_var_params and local_var_params['max_status_code'] is not None:  # noqa: E501
            query_params.append(('maxStatusCode', local_var_params['max_status_code']))  # 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 'sms_id' in local_var_params and local_var_params['sms_id'] is not None:  # noqa: E501
            query_params.append(('smsId', local_var_params['sms_id']))  # noqa: E501
        if 'attachment_id' in local_var_params and local_var_params['attachment_id'] is not None:  # noqa: E501
            query_params.append(('attachmentId', local_var_params['attachment_id']))  # noqa: E501
        if 'email_id' in local_var_params and local_var_params['email_id'] is not None:  # noqa: E501
            query_params.append(('emailId', local_var_params['email_id']))  # noqa: E501
        if 'phone_id' in local_var_params and local_var_params['phone_id'] is not None:  # noqa: E501
            query_params.append(('phoneId', local_var_params['phone_id']))  # 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(
            '/webhooks/{webhookId}/results', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageWebhookResult',  # 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_webhook_results_count(self, webhook_id, **kwargs):  # noqa: E501
        """Get a webhook results count for a webhook  # 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_webhook_results_count(webhook_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_id: ID of webhook to get results for (required)
        :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: CountDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_webhook_results_count_with_http_info(webhook_id, **kwargs)  # noqa: E501

    def get_webhook_results_count_with_http_info(self, webhook_id, **kwargs):  # noqa: E501
        """Get a webhook results count for a webhook  # 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_webhook_results_count_with_http_info(webhook_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_id: ID of webhook to get results for (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(CountDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'webhook_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_webhook_results_count" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'webhook_id' is set
        if self.api_client.client_side_validation and ('webhook_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['webhook_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `webhook_id` when calling `get_webhook_results_count`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'webhook_id' in local_var_params:
            path_params['webhookId'] = local_var_params['webhook_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/{webhookId}/results/count', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CountDto',  # 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_webhook_results_unseen_error_count(self, **kwargs):  # noqa: E501
        """Get count of unseen webhook results with error status  # 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_webhook_results_unseen_error_count(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: UnseenErrorCountDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_webhook_results_unseen_error_count_with_http_info(**kwargs)  # noqa: E501

    def get_webhook_results_unseen_error_count_with_http_info(self, **kwargs):  # noqa: E501
        """Get count of unseen webhook results with error status  # 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_webhook_results_unseen_error_count_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(UnseenErrorCountDto, 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_webhook_results_unseen_error_count" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/results/unseen-count', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='UnseenErrorCountDto',  # 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_webhooks(self, inbox_id, **kwargs):  # noqa: E501
        """Get all webhooks for 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_webhooks(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :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: list[WebhookDto]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_webhooks_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def get_webhooks_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """Get all webhooks for 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_webhooks_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_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: tuple(list[WebhookDto], status_code(int), headers(HTTPHeaderDict))
                 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 get_webhooks" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `get_webhooks`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/inboxes/{inboxId}/webhooks', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[WebhookDto]',  # 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 redrive_all_webhook_results(self, **kwargs):  # noqa: E501
        """Redrive all webhook results that have failed status  # noqa: E501

        Allows you to resend webhook payloads for any recorded webhook result that failed to deliver the payload.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.redrive_all_webhook_results(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: WebhookRedriveAllResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.redrive_all_webhook_results_with_http_info(**kwargs)  # noqa: E501

    def redrive_all_webhook_results_with_http_info(self, **kwargs):  # noqa: E501
        """Redrive all webhook results that have failed status  # noqa: E501

        Allows you to resend webhook payloads for any recorded webhook result that failed to deliver the payload.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.redrive_all_webhook_results_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(WebhookRedriveAllResult, 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 redrive_all_webhook_results" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/results/redrive', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookRedriveAllResult',  # 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 redrive_webhook_result(self, webhook_result_id, **kwargs):  # noqa: E501
        """Get a webhook result and try to resend the original webhook payload  # noqa: E501

        Allows you to resend a webhook payload that was already sent. Webhooks that fail are retried automatically for 24 hours and then put in a dead letter queue. You can retry results manually using this 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.redrive_webhook_result(webhook_result_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_result_id: Webhook Result ID (required)
        :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: WebhookRedriveResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.redrive_webhook_result_with_http_info(webhook_result_id, **kwargs)  # noqa: E501

    def redrive_webhook_result_with_http_info(self, webhook_result_id, **kwargs):  # noqa: E501
        """Get a webhook result and try to resend the original webhook payload  # noqa: E501

        Allows you to resend a webhook payload that was already sent. Webhooks that fail are retried automatically for 24 hours and then put in a dead letter queue. You can retry results manually using this 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.redrive_webhook_result_with_http_info(webhook_result_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_result_id: Webhook Result 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: tuple(WebhookRedriveResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'webhook_result_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 redrive_webhook_result" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'webhook_result_id' is set
        if self.api_client.client_side_validation and ('webhook_result_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['webhook_result_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `webhook_result_id` when calling `redrive_webhook_result`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'webhook_result_id' in local_var_params:
            path_params['webhookResultId'] = local_var_params['webhook_result_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/results/{webhookResultId}/redrive', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookRedriveResult',  # 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 send_test_data(self, webhook_id, **kwargs):  # noqa: E501
        """Send webhook test 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.send_test_data(webhook_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_id: (required)
        :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: WebhookTestResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.send_test_data_with_http_info(webhook_id, **kwargs)  # noqa: E501

    def send_test_data_with_http_info(self, webhook_id, **kwargs):  # noqa: E501
        """Send webhook test 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.send_test_data_with_http_info(webhook_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_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: tuple(WebhookTestResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'webhook_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 send_test_data" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'webhook_id' is set
        if self.api_client.client_side_validation and ('webhook_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['webhook_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `webhook_id` when calling `send_test_data`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'webhook_id' in local_var_params:
            path_params['webhookId'] = local_var_params['webhook_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/webhooks/{webhookId}/test', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookTestResult',  # 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_webhook_headers(self, webhook_id, webhook_headers, **kwargs):  # noqa: E501
        """Update a webhook request headers  # 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_webhook_headers(webhook_id, webhook_headers, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_id: (required)
        :param WebhookHeaders webhook_headers: (required)
        :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: WebhookDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_webhook_headers_with_http_info(webhook_id, webhook_headers, **kwargs)  # noqa: E501

    def update_webhook_headers_with_http_info(self, webhook_id, webhook_headers, **kwargs):  # noqa: E501
        """Update a webhook request headers  # 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_webhook_headers_with_http_info(webhook_id, webhook_headers, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_id: (required)
        :param WebhookHeaders webhook_headers: (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(WebhookDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'webhook_id',
            'webhook_headers'
        ]
        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_webhook_headers" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'webhook_id' is set
        if self.api_client.client_side_validation and ('webhook_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['webhook_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `webhook_id` when calling `update_webhook_headers`")  # noqa: E501
        # verify the required parameter 'webhook_headers' is set
        if self.api_client.client_side_validation and ('webhook_headers' not in local_var_params or  # noqa: E501
                                                        local_var_params['webhook_headers'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `webhook_headers` when calling `update_webhook_headers`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'webhook_id' in local_var_params:
            path_params['webhookId'] = local_var_params['webhook_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'webhook_headers' in local_var_params:
            body_params = local_var_params['webhook_headers']
        # 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(
            '/webhooks/{webhookId}/headers', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='WebhookDto',  # 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_webhook_signature(self, verify_webhook_signature_options, **kwargs):  # noqa: E501
        """Verify a webhook payload signature  # noqa: E501

        Verify a webhook payload using the messageId and signature. This allows you to be sure that MailSlurp sent the payload and not another 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_webhook_signature(verify_webhook_signature_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param VerifyWebhookSignatureOptions verify_webhook_signature_options: (required)
        :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: VerifyWebhookSignatureResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.verify_webhook_signature_with_http_info(verify_webhook_signature_options, **kwargs)  # noqa: E501

    def verify_webhook_signature_with_http_info(self, verify_webhook_signature_options, **kwargs):  # noqa: E501
        """Verify a webhook payload signature  # noqa: E501

        Verify a webhook payload using the messageId and signature. This allows you to be sure that MailSlurp sent the payload and not another 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_webhook_signature_with_http_info(verify_webhook_signature_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param VerifyWebhookSignatureOptions verify_webhook_signature_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(VerifyWebhookSignatureResults, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'verify_webhook_signature_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_webhook_signature" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'verify_webhook_signature_options' is set
        if self.api_client.client_side_validation and ('verify_webhook_signature_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['verify_webhook_signature_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `verify_webhook_signature_options` when calling `verify_webhook_signature`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'verify_webhook_signature_options' in local_var_params:
            body_params = local_var_params['verify_webhook_signature_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(
            '/webhooks/verify', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='VerifyWebhookSignatureResults',  # 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_webhook_results(self, webhook_id, expected_count, timeout, **kwargs):  # noqa: E501
        """Wait for webhook results for a webhook  # 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_webhook_results(webhook_id, expected_count, timeout, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_id: ID of webhook to get results for (required)
        :param int expected_count: Expected result count (required)
        :param int timeout: Max time to wait in milliseconds (required)
        :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: list[WebhookResultDto]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.wait_for_webhook_results_with_http_info(webhook_id, expected_count, timeout, **kwargs)  # noqa: E501

    def wait_for_webhook_results_with_http_info(self, webhook_id, expected_count, timeout, **kwargs):  # noqa: E501
        """Wait for webhook results for a webhook  # 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_webhook_results_with_http_info(webhook_id, expected_count, timeout, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str webhook_id: ID of webhook to get results for (required)
        :param int expected_count: Expected result count (required)
        :param int timeout: Max time to wait in milliseconds (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[WebhookResultDto], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'webhook_id',
            'expected_count',
            'timeout'
        ]
        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_webhook_results" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'webhook_id' is set
        if self.api_client.client_side_validation and ('webhook_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['webhook_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `webhook_id` when calling `wait_for_webhook_results`")  # noqa: E501
        # verify the required parameter 'expected_count' is set
        if self.api_client.client_side_validation and ('expected_count' not in local_var_params or  # noqa: E501
                                                        local_var_params['expected_count'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `expected_count` when calling `wait_for_webhook_results`")  # noqa: E501
        # verify the required parameter 'timeout' is set
        if self.api_client.client_side_validation and ('timeout' not in local_var_params or  # noqa: E501
                                                        local_var_params['timeout'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `timeout` when calling `wait_for_webhook_results`")  # noqa: E501

        if self.api_client.client_side_validation and 'expected_count' in local_var_params and local_var_params['expected_count'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `expected_count` when calling `wait_for_webhook_results`, must be a value less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and 'timeout' in local_var_params and local_var_params['timeout'] > 300000:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `timeout` when calling `wait_for_webhook_results`, must be a value less than or equal to `300000`")  # noqa: E501
        if self.api_client.client_side_validation and 'timeout' in local_var_params and local_var_params['timeout'] < 1000:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `timeout` when calling `wait_for_webhook_results`, must be a value greater than or equal to `1000`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'webhook_id' in local_var_params:
            path_params['webhookId'] = local_var_params['webhook_id']  # noqa: E501

        query_params = []
        if 'expected_count' in local_var_params and local_var_params['expected_count'] is not None:  # noqa: E501
            query_params.append(('expectedCount', local_var_params['expected_count']))  # 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

        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(
            '/webhooks/{webhookId}/wait', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[WebhookResultDto]',  # 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)

mailslurp_client/api/wait_for_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class WaitForControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def wait_for(self, wait_for_conditions, **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(wait_for_conditions, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param WaitForConditions wait_for_conditions: (required)
        :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: list[EmailPreview]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.wait_for_with_http_info(wait_for_conditions, **kwargs)  # noqa: E501

    def wait_for_with_http_info(self, wait_for_conditions, **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(wait_for_conditions, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param WaitForConditions wait_for_conditions: (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[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']
        # verify the required parameter 'wait_for_conditions' is set
        if self.api_client.client_side_validation and ('wait_for_conditions' not in local_var_params or  # noqa: E501
                                                        local_var_params['wait_for_conditions'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `wait_for_conditions` when calling `wait_for`")  # noqa: E501

        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(
            ['*/*'])  # 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 wait_for_email_count(self, inbox_id, count, **kwargs):  # noqa: E501
        """Wait for and return count number of emails. Hold connection until inbox count matches expected or timeout occurs  # noqa: E501

        If inbox contains count or more emails at time of request then return count worth of emails. If not wait until the count is reached and return those or return an error if timeout is exceeded.  # 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_email_count(inbox_id, count, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Id of the inbox we are fetching emails from (required)
        :param int count: Number of emails to wait for. Must be greater that 1 (required)
        :param int timeout: Max milliseconds to wait
        :param bool unread_only: Optional filter for unread only
        :param datetime before: Filter for emails that were received before the given timestamp
        :param datetime since: Filter for emails that were received after the given timestamp
        :param str sort: Sort direction
        :param int delay: Max milliseconds delay between calls
        :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: list[EmailPreview]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.wait_for_email_count_with_http_info(inbox_id, count, **kwargs)  # noqa: E501

    def wait_for_email_count_with_http_info(self, inbox_id, count, **kwargs):  # noqa: E501
        """Wait for and return count number of emails. Hold connection until inbox count matches expected or timeout occurs  # noqa: E501

        If inbox contains count or more emails at time of request then return count worth of emails. If not wait until the count is reached and return those or return an error if timeout is exceeded.  # 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_email_count_with_http_info(inbox_id, count, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Id of the inbox we are fetching emails from (required)
        :param int count: Number of emails to wait for. Must be greater that 1 (required)
        :param int timeout: Max milliseconds to wait
        :param bool unread_only: Optional filter for unread only
        :param datetime before: Filter for emails that were received before the given timestamp
        :param datetime since: Filter for emails that were received after the given timestamp
        :param str sort: Sort direction
        :param int delay: Max milliseconds delay between calls
        :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 = [
            'inbox_id',
            'count',
            'timeout',
            'unread_only',
            'before',
            'since',
            'sort',
            'delay'
        ]
        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_email_count" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `wait_for_email_count`")  # noqa: E501
        # 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 `wait_for_email_count`")  # noqa: E501

        if self.api_client.client_side_validation and 'count' in local_var_params and local_var_params['count'] < 1:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `count` when calling `wait_for_email_count`, must be a value greater than or equal to `1`")  # 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 '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
        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
        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 '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 '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

        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(
            '/waitForEmailCount', 'GET',
            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 wait_for_latest_email(self, **kwargs):  # noqa: E501
        """Fetch inbox's latest email or if empty wait for an email to arrive  # noqa: E501

        Will return either the last received email or wait for an email to arrive and return that. If you need to wait for an email for a non-empty inbox set `unreadOnly=true` or see the other receive methods such as `waitForNthEmail` or `waitForEmailCount`.  # 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_latest_email(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Id of the inbox we are fetching emails from
        :param int timeout: Max milliseconds to wait
        :param bool unread_only: Optional filter for unread only.
        :param datetime before: Filter for emails that were before after the given timestamp
        :param datetime since: Filter for emails that were received after the given timestamp
        :param str sort: Sort direction
        :param int delay: Max milliseconds delay between calls
        :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: Email
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.wait_for_latest_email_with_http_info(**kwargs)  # noqa: E501

    def wait_for_latest_email_with_http_info(self, **kwargs):  # noqa: E501
        """Fetch inbox's latest email or if empty wait for an email to arrive  # noqa: E501

        Will return either the last received email or wait for an email to arrive and return that. If you need to wait for an email for a non-empty inbox set `unreadOnly=true` or see the other receive methods such as `waitForNthEmail` or `waitForEmailCount`.  # 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_latest_email_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Id of the inbox we are fetching emails from
        :param int timeout: Max milliseconds to wait
        :param bool unread_only: Optional filter for unread only.
        :param datetime before: Filter for emails that were before after the given timestamp
        :param datetime since: Filter for emails that were received after the given timestamp
        :param str sort: Sort direction
        :param int delay: Max milliseconds delay between calls
        :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 = [
            'inbox_id',
            'timeout',
            'unread_only',
            'before',
            'since',
            'sort',
            'delay'
        ]
        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_latest_email" % 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 '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
        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 '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 '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

        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(
            '/waitForLatestEmail', '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 wait_for_latest_sms(self, wait_for_single_sms_options, **kwargs):  # noqa: E501
        """Wait for the latest SMS message to match the provided filter conditions such as body contains keyword.  # noqa: E501

        Wait until a phone number 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_latest_sms(wait_for_single_sms_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param WaitForSingleSmsOptions wait_for_single_sms_options: (required)
        :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: SmsDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.wait_for_latest_sms_with_http_info(wait_for_single_sms_options, **kwargs)  # noqa: E501

    def wait_for_latest_sms_with_http_info(self, wait_for_single_sms_options, **kwargs):  # noqa: E501
        """Wait for the latest SMS message to match the provided filter conditions such as body contains keyword.  # noqa: E501

        Wait until a phone number 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_latest_sms_with_http_info(wait_for_single_sms_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param WaitForSingleSmsOptions wait_for_single_sms_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(SmsDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'wait_for_single_sms_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 wait_for_latest_sms" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'wait_for_single_sms_options' is set
        if self.api_client.client_side_validation and ('wait_for_single_sms_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['wait_for_single_sms_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `wait_for_single_sms_options` when calling `wait_for_latest_sms`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'wait_for_single_sms_options' in local_var_params:
            body_params = local_var_params['wait_for_single_sms_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(
            '/waitForLatestSms', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SmsDto',  # 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_emails(self, inbox_id, count, match_options, **kwargs):  # noqa: E501
        """Wait or return list of emails that match simple matching patterns  # noqa: E501

        Perform a search of emails in an inbox with the given patterns. If results match expected count then return or else retry the search until results are 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_emails(inbox_id, count, match_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Id of the inbox we are fetching emails from (required)
        :param int count: Number of emails to wait for. Must be greater or equal to 1 (required)
        :param MatchOptions match_options: (required)
        :param datetime before: Filter for emails that were received before the given timestamp
        :param datetime since: Filter for emails that were received after the given timestamp
        :param str sort: Sort direction
        :param int delay: Max milliseconds delay between calls
        :param int timeout: Max milliseconds to wait
        :param bool unread_only: Optional filter for unread only
        :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: list[EmailPreview]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.wait_for_matching_emails_with_http_info(inbox_id, count, match_options, **kwargs)  # noqa: E501

    def wait_for_matching_emails_with_http_info(self, inbox_id, count, match_options, **kwargs):  # noqa: E501
        """Wait or return list of emails that match simple matching patterns  # noqa: E501

        Perform a search of emails in an inbox with the given patterns. If results match expected count then return or else retry the search until results are 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_emails_with_http_info(inbox_id, count, match_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Id of the inbox we are fetching emails from (required)
        :param int count: Number of emails to wait for. Must be greater or equal to 1 (required)
        :param MatchOptions match_options: (required)
        :param datetime before: Filter for emails that were received before the given timestamp
        :param datetime since: Filter for emails that were received after the given timestamp
        :param str sort: Sort direction
        :param int delay: Max milliseconds delay between calls
        :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(list[EmailPreview], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'count',
            'match_options',
            'before',
            'since',
            'sort',
            'delay',
            '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_emails" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `wait_for_matching_emails`")  # noqa: E501
        # 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 `wait_for_matching_emails`")  # noqa: E501
        # 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_emails`")  # noqa: E501

        if self.api_client.client_side_validation and 'count' in local_var_params and local_var_params['count'] < 1:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `count` when calling `wait_for_matching_emails`, must be a value greater than or equal to `1`")  # 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 '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
        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 '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 '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 '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(
            ['*/*'])  # 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(
            '/waitForMatchingEmails', '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 wait_for_matching_first_email(self, inbox_id, 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(inbox_id, match_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Id of the inbox we are matching an email for (required)
        :param MatchOptions match_options: (required)
        :param int timeout: Max milliseconds to wait
        :param bool unread_only: Optional filter for unread only
        :param datetime since: Filter for emails that were received after the given timestamp
        :param datetime before: Filter for emails that were received before the given timestamp
        :param str sort: Sort direction
        :param int delay: Max milliseconds delay between calls
        :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: Email
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.wait_for_matching_first_email_with_http_info(inbox_id, match_options, **kwargs)  # noqa: E501

    def wait_for_matching_first_email_with_http_info(self, inbox_id, 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(inbox_id, match_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Id of the inbox we are matching an email for (required)
        :param MatchOptions match_options: (required)
        :param int timeout: Max milliseconds to wait
        :param bool unread_only: Optional filter for unread only
        :param datetime since: Filter for emails that were received after the given timestamp
        :param datetime before: Filter for emails that were received before the given timestamp
        :param str sort: Sort direction
        :param int delay: Max milliseconds delay between calls
        :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 = [
            'inbox_id',
            'match_options',
            'timeout',
            'unread_only',
            'since',
            'before',
            'sort',
            'delay'
        ]
        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 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `wait_for_matching_first_email`")  # noqa: E501
        # 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 '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 '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
        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 '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 '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

        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(
            ['*/*'])  # 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)

    def wait_for_nth_email(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(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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 int timeout: Max milliseconds to wait for the nth email if not already present
        :param bool unread_only: Optional filter for unread only
        :param datetime since: Filter for emails that were received after the given timestamp
        :param datetime before: Filter for emails that were received before the given timestamp
        :param str sort: Sort direction
        :param int delay: Max milliseconds delay between calls
        :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: Email
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.wait_for_nth_email_with_http_info(**kwargs)  # noqa: E501

    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 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 int timeout: Max milliseconds to wait for the nth email if not already present
        :param bool unread_only: Optional filter for unread only
        :param datetime since: Filter for emails that were received after the given timestamp
        :param datetime before: Filter for emails that were received before the given timestamp
        :param str sort: Sort direction
        :param int delay: Max milliseconds delay between calls
        :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 = [
            'inbox_id',
            'index',
            'timeout',
            'unread_only',
            'since',
            'before',
            'sort',
            'delay'
        ]
        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']

        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_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_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 '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 '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
        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 '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 '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

        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(
            '/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 wait_for_sms(self, wait_for_sms_conditions, **kwargs):  # noqa: E501
        """Wait for an SMS message to match the provided filter conditions such as body contains keyword.  # noqa: E501

        Generic waitFor method that will wait until a phone number 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_sms(wait_for_sms_conditions, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param WaitForSmsConditions wait_for_sms_conditions: (required)
        :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: list[SmsPreview]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.wait_for_sms_with_http_info(wait_for_sms_conditions, **kwargs)  # noqa: E501

    def wait_for_sms_with_http_info(self, wait_for_sms_conditions, **kwargs):  # noqa: E501
        """Wait for an SMS message to match the provided filter conditions such as body contains keyword.  # noqa: E501

        Generic waitFor method that will wait until a phone number 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_sms_with_http_info(wait_for_sms_conditions, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param WaitForSmsConditions wait_for_sms_conditions: (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[SmsPreview], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'wait_for_sms_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_sms" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'wait_for_sms_conditions' is set
        if self.api_client.client_side_validation and ('wait_for_sms_conditions' not in local_var_params or  # noqa: E501
                                                        local_var_params['wait_for_sms_conditions'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `wait_for_sms_conditions` when calling `wait_for_sms`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'wait_for_sms_conditions' in local_var_params:
            body_params = local_var_params['wait_for_sms_conditions']
        # 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(
            '/waitForSms', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[SmsPreview]',  # 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)

mailslurp_client/api/user_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class UserControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def get_json_property_as_string(self, _property, body, **kwargs):  # noqa: E501
        """get_json_property_as_string  # noqa: E501

        Utility function to extract properties from JSON objects in language where this is cumbersome.  # 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_json_property_as_string(_property, body, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str _property: JSON property name or dot separated path selector such as `a.b.c` (required)
        :param object body: (required)
        :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: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_json_property_as_string_with_http_info(_property, body, **kwargs)  # noqa: E501

    def get_json_property_as_string_with_http_info(self, _property, body, **kwargs):  # noqa: E501
        """get_json_property_as_string  # noqa: E501

        Utility function to extract properties from JSON objects in language where this is cumbersome.  # 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_json_property_as_string_with_http_info(_property, body, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str _property: JSON property name or dot separated path selector such as `a.b.c` (required)
        :param object body: (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(str, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            '_property',
            'body'
        ]
        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_json_property_as_string" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter '_property' is set
        if self.api_client.client_side_validation and ('_property' not in local_var_params or  # noqa: E501
                                                        local_var_params['_property'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `_property` when calling `get_json_property_as_string`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if '_property' in local_var_params and local_var_params['_property'] is not None:  # noqa: E501
            query_params.append(('property', local_var_params['_property']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'body' in local_var_params:
            body_params = local_var_params['body']
        # 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(
            '/user/json/pluck', '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_user_info(self, **kwargs):  # noqa: E501
        """get_user_info  # noqa: E501

        Get account information for your user  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_user_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: UserInfoDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_user_info_with_http_info(**kwargs)  # noqa: E501

    def get_user_info_with_http_info(self, **kwargs):  # noqa: E501
        """get_user_info  # noqa: E501

        Get account information for your user  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_user_info_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(UserInfoDto, 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_user_info" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/user/info', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='UserInfoDto',  # 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)

mailslurp_client/api/tracking_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class TrackingControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def create_tracking_pixel(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(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 _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: TrackingPixelDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_tracking_pixel_with_http_info(create_tracking_pixel_options, **kwargs)  # noqa: E501

    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_all_tracking_pixels(self, **kwargs):  # noqa: E501
        """Get tracking pixels  # noqa: E501

        List tracking pixels in paginated form  # 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_all_tracking_pixels(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 in list pagination
        :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 _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: PageTrackingPixelProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_all_tracking_pixels_with_http_info(**kwargs)  # noqa: E501

    def get_all_tracking_pixels_with_http_info(self, **kwargs):  # noqa: E501
        """Get tracking pixels  # noqa: E501

        List tracking pixels in paginated form  # 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_all_tracking_pixels_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 in list pagination
        :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 _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(PageTrackingPixelProjection, 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'
        ]
        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_all_tracking_pixels" % 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
        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

        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(
            '/tracking/pixels', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageTrackingPixelProjection',  # 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_tracking_pixel(self, id, **kwargs):  # noqa: E501
        """Get 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.get_tracking_pixel(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :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: TrackingPixelDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_tracking_pixel_with_http_info(id, **kwargs)  # noqa: E501

    def get_tracking_pixel_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get 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.get_tracking_pixel_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str 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: tuple(TrackingPixelDto, 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_tracking_pixel" % 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_tracking_pixel`")  # 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/tracking/pixels/{id}', 'GET',
            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)

mailslurp_client/api/tools_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class ToolsControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def check_email_features_client_support(self, check_email_features_client_support_options, **kwargs):  # noqa: E501
        """Check email client support for email HTML and CSS features  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.check_email_features_client_support(check_email_features_client_support_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CheckEmailFeaturesClientSupportOptions check_email_features_client_support_options: (required)
        :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: CheckEmailFeaturesClientSupportResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.check_email_features_client_support_with_http_info(check_email_features_client_support_options, **kwargs)  # noqa: E501

    def check_email_features_client_support_with_http_info(self, check_email_features_client_support_options, **kwargs):  # noqa: E501
        """Check email client support for email HTML and CSS features  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.check_email_features_client_support_with_http_info(check_email_features_client_support_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CheckEmailFeaturesClientSupportOptions check_email_features_client_support_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(CheckEmailFeaturesClientSupportResults, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'check_email_features_client_support_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 check_email_features_client_support" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'check_email_features_client_support_options' is set
        if self.api_client.client_side_validation and ('check_email_features_client_support_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['check_email_features_client_support_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `check_email_features_client_support_options` when calling `check_email_features_client_support`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'check_email_features_client_support_options' in local_var_params:
            body_params = local_var_params['check_email_features_client_support_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(
            '/tools/check-email-features-client-support', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CheckEmailFeaturesClientSupportResults',  # 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_fake_email_address(self, **kwargs):  # noqa: E501
        """Create a new email address using the fake email domains  # 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_fake_email_address(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: NewFakeEmailAddressResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_new_fake_email_address_with_http_info(**kwargs)  # noqa: E501

    def create_new_fake_email_address_with_http_info(self, **kwargs):  # noqa: E501
        """Create a new email address using the fake email domains  # 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_fake_email_address_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(NewFakeEmailAddressResult, 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 create_new_fake_email_address" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/tools/fake-email', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='NewFakeEmailAddressResult',  # 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 generate_bimi_record(self, generate_bimi_record_options, **kwargs):  # noqa: E501
        """Create a BIMI record policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_bimi_record(generate_bimi_record_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param GenerateBimiRecordOptions generate_bimi_record_options: (required)
        :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: GenerateBimiRecordResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.generate_bimi_record_with_http_info(generate_bimi_record_options, **kwargs)  # noqa: E501

    def generate_bimi_record_with_http_info(self, generate_bimi_record_options, **kwargs):  # noqa: E501
        """Create a BIMI record policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_bimi_record_with_http_info(generate_bimi_record_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param GenerateBimiRecordOptions generate_bimi_record_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(GenerateBimiRecordResults, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'generate_bimi_record_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 generate_bimi_record" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'generate_bimi_record_options' is set
        if self.api_client.client_side_validation and ('generate_bimi_record_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['generate_bimi_record_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `generate_bimi_record_options` when calling `generate_bimi_record`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'generate_bimi_record_options' in local_var_params:
            body_params = local_var_params['generate_bimi_record_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(
            '/tools/generate-bimi-record', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GenerateBimiRecordResults',  # 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 generate_dmarc_record(self, generate_dmarc_record_options, **kwargs):  # noqa: E501
        """Create a DMARC record policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_dmarc_record(generate_dmarc_record_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param GenerateDmarcRecordOptions generate_dmarc_record_options: (required)
        :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: GenerateDmarcRecordResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.generate_dmarc_record_with_http_info(generate_dmarc_record_options, **kwargs)  # noqa: E501

    def generate_dmarc_record_with_http_info(self, generate_dmarc_record_options, **kwargs):  # noqa: E501
        """Create a DMARC record policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_dmarc_record_with_http_info(generate_dmarc_record_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param GenerateDmarcRecordOptions generate_dmarc_record_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(GenerateDmarcRecordResults, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'generate_dmarc_record_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 generate_dmarc_record" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'generate_dmarc_record_options' is set
        if self.api_client.client_side_validation and ('generate_dmarc_record_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['generate_dmarc_record_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `generate_dmarc_record_options` when calling `generate_dmarc_record`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'generate_dmarc_record_options' in local_var_params:
            body_params = local_var_params['generate_dmarc_record_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(
            '/tools/generate-dmarc-record', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GenerateDmarcRecordResults',  # 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 generate_mta_sts_record(self, generate_mta_sts_record_options, **kwargs):  # noqa: E501
        """Create a TLS reporting record policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_mta_sts_record(generate_mta_sts_record_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param GenerateMtaStsRecordOptions generate_mta_sts_record_options: (required)
        :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: GenerateMtaStsRecordResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.generate_mta_sts_record_with_http_info(generate_mta_sts_record_options, **kwargs)  # noqa: E501

    def generate_mta_sts_record_with_http_info(self, generate_mta_sts_record_options, **kwargs):  # noqa: E501
        """Create a TLS reporting record policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_mta_sts_record_with_http_info(generate_mta_sts_record_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param GenerateMtaStsRecordOptions generate_mta_sts_record_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(GenerateMtaStsRecordResults, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'generate_mta_sts_record_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 generate_mta_sts_record" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'generate_mta_sts_record_options' is set
        if self.api_client.client_side_validation and ('generate_mta_sts_record_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['generate_mta_sts_record_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `generate_mta_sts_record_options` when calling `generate_mta_sts_record`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'generate_mta_sts_record_options' in local_var_params:
            body_params = local_var_params['generate_mta_sts_record_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(
            '/tools/generate-mta-sts-record', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GenerateMtaStsRecordResults',  # 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 generate_tls_reporting_record(self, generate_tls_reporting_record_options, **kwargs):  # noqa: E501
        """Create a TLS reporting record policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_tls_reporting_record(generate_tls_reporting_record_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param GenerateTlsReportingRecordOptions generate_tls_reporting_record_options: (required)
        :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: GenerateTlsReportingRecordResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.generate_tls_reporting_record_with_http_info(generate_tls_reporting_record_options, **kwargs)  # noqa: E501

    def generate_tls_reporting_record_with_http_info(self, generate_tls_reporting_record_options, **kwargs):  # noqa: E501
        """Create a TLS reporting record policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.generate_tls_reporting_record_with_http_info(generate_tls_reporting_record_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param GenerateTlsReportingRecordOptions generate_tls_reporting_record_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(GenerateTlsReportingRecordResults, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'generate_tls_reporting_record_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 generate_tls_reporting_record" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'generate_tls_reporting_record_options' is set
        if self.api_client.client_side_validation and ('generate_tls_reporting_record_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['generate_tls_reporting_record_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `generate_tls_reporting_record_options` when calling `generate_tls_reporting_record`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'generate_tls_reporting_record_options' in local_var_params:
            body_params = local_var_params['generate_tls_reporting_record_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(
            '/tools/generate-tls-reporting-record', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GenerateTlsReportingRecordResults',  # 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_fake_email_by_id(self, id, **kwargs):  # noqa: E501
        """get_fake_email_by_id  # 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_fake_email_by_id(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :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: FakeEmailResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_fake_email_by_id_with_http_info(id, **kwargs)  # noqa: E501

    def get_fake_email_by_id_with_http_info(self, id, **kwargs):  # noqa: E501
        """get_fake_email_by_id  # 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_fake_email_by_id_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str 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: tuple(FakeEmailResult, 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_fake_email_by_id" % 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_fake_email_by_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'id' in local_var_params and local_var_params['id'] is not None:  # noqa: E501
            query_params.append(('id', local_var_params['id']))  # 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(
            '/tools/fake-email', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FakeEmailResult',  # 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_fake_emails_for_address(self, email_address, **kwargs):  # noqa: E501
        """get_fake_emails_for_address  # 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_fake_emails_for_address(email_address, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_address: (required)
        :param int page:
        :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: list[FakeEmailPreview]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_fake_emails_for_address_with_http_info(email_address, **kwargs)  # noqa: E501

    def get_fake_emails_for_address_with_http_info(self, email_address, **kwargs):  # noqa: E501
        """get_fake_emails_for_address  # 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_fake_emails_for_address_with_http_info(email_address, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_address: (required)
        :param int page:
        :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[FakeEmailPreview], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_address',
            'page'
        ]
        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_fake_emails_for_address" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_address' is set
        if self.api_client.client_side_validation and ('email_address' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_address'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_address` when calling `get_fake_emails_for_address`")  # 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 'email_address' in local_var_params and local_var_params['email_address'] is not None:  # noqa: E501
            query_params.append(('emailAddress', local_var_params['email_address']))  # 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(
            '/tools/fake-emails', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[FakeEmailPreview]',  # 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 lookup_bimi_domain(self, lookup_bimi_domain_options, **kwargs):  # noqa: E501
        """Lookup a BIMI record policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.lookup_bimi_domain(lookup_bimi_domain_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param LookupBimiDomainOptions lookup_bimi_domain_options: (required)
        :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: LookupBimiDomainResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.lookup_bimi_domain_with_http_info(lookup_bimi_domain_options, **kwargs)  # noqa: E501

    def lookup_bimi_domain_with_http_info(self, lookup_bimi_domain_options, **kwargs):  # noqa: E501
        """Lookup a BIMI record policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.lookup_bimi_domain_with_http_info(lookup_bimi_domain_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param LookupBimiDomainOptions lookup_bimi_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(LookupBimiDomainResults, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'lookup_bimi_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 lookup_bimi_domain" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'lookup_bimi_domain_options' is set
        if self.api_client.client_side_validation and ('lookup_bimi_domain_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['lookup_bimi_domain_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `lookup_bimi_domain_options` when calling `lookup_bimi_domain`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'lookup_bimi_domain_options' in local_var_params:
            body_params = local_var_params['lookup_bimi_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(
            '/tools/lookup-bimi-domain', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='LookupBimiDomainResults',  # 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 lookup_dmarc_domain(self, lookup_dmarc_domain_options, **kwargs):  # noqa: E501
        """Lookup a DMARC record policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.lookup_dmarc_domain(lookup_dmarc_domain_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param LookupDmarcDomainOptions lookup_dmarc_domain_options: (required)
        :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: LookupDmarcDomainResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.lookup_dmarc_domain_with_http_info(lookup_dmarc_domain_options, **kwargs)  # noqa: E501

    def lookup_dmarc_domain_with_http_info(self, lookup_dmarc_domain_options, **kwargs):  # noqa: E501
        """Lookup a DMARC record policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.lookup_dmarc_domain_with_http_info(lookup_dmarc_domain_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param LookupDmarcDomainOptions lookup_dmarc_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(LookupDmarcDomainResults, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'lookup_dmarc_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 lookup_dmarc_domain" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'lookup_dmarc_domain_options' is set
        if self.api_client.client_side_validation and ('lookup_dmarc_domain_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['lookup_dmarc_domain_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `lookup_dmarc_domain_options` when calling `lookup_dmarc_domain`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'lookup_dmarc_domain_options' in local_var_params:
            body_params = local_var_params['lookup_dmarc_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(
            '/tools/lookup-dmarc-domain', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='LookupDmarcDomainResults',  # 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 lookup_mta_sts_domain(self, lookup_mta_sts_domain_options, **kwargs):  # noqa: E501
        """Lookup a MTA-STS domain policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.lookup_mta_sts_domain(lookup_mta_sts_domain_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param LookupMtaStsDomainOptions lookup_mta_sts_domain_options: (required)
        :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: LookupMtaStsDomainResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.lookup_mta_sts_domain_with_http_info(lookup_mta_sts_domain_options, **kwargs)  # noqa: E501

    def lookup_mta_sts_domain_with_http_info(self, lookup_mta_sts_domain_options, **kwargs):  # noqa: E501
        """Lookup a MTA-STS domain policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.lookup_mta_sts_domain_with_http_info(lookup_mta_sts_domain_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param LookupMtaStsDomainOptions lookup_mta_sts_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(LookupMtaStsDomainResults, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'lookup_mta_sts_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 lookup_mta_sts_domain" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'lookup_mta_sts_domain_options' is set
        if self.api_client.client_side_validation and ('lookup_mta_sts_domain_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['lookup_mta_sts_domain_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `lookup_mta_sts_domain_options` when calling `lookup_mta_sts_domain`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'lookup_mta_sts_domain_options' in local_var_params:
            body_params = local_var_params['lookup_mta_sts_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(
            '/tools/lookup-mta-sts-domain', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='LookupMtaStsDomainResults',  # 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 lookup_tls_reporting_domain(self, lookup_tls_reporting_domain_options, **kwargs):  # noqa: E501
        """Lookup a TLS reporting domain policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.lookup_tls_reporting_domain(lookup_tls_reporting_domain_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param LookupTlsReportingDomainOptions lookup_tls_reporting_domain_options: (required)
        :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: LookupTlsReportingDomainResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.lookup_tls_reporting_domain_with_http_info(lookup_tls_reporting_domain_options, **kwargs)  # noqa: E501

    def lookup_tls_reporting_domain_with_http_info(self, lookup_tls_reporting_domain_options, **kwargs):  # noqa: E501
        """Lookup a TLS reporting domain policy  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.lookup_tls_reporting_domain_with_http_info(lookup_tls_reporting_domain_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param LookupTlsReportingDomainOptions lookup_tls_reporting_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(LookupTlsReportingDomainResults, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'lookup_tls_reporting_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 lookup_tls_reporting_domain" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'lookup_tls_reporting_domain_options' is set
        if self.api_client.client_side_validation and ('lookup_tls_reporting_domain_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['lookup_tls_reporting_domain_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `lookup_tls_reporting_domain_options` when calling `lookup_tls_reporting_domain`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'lookup_tls_reporting_domain_options' in local_var_params:
            body_params = local_var_params['lookup_tls_reporting_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(
            '/tools/lookup-tls-reporting-domain', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='LookupTlsReportingDomainResults',  # 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)

mailslurp_client/api/template_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class TemplateControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def create_template(self, create_template_options, **kwargs):  # noqa: E501
        """Create a Template  # noqa: E501

        Create an email template with variables for use with templated transactional 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.create_template(create_template_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateTemplateOptions create_template_options: (required)
        :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: TemplateDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_template_with_http_info(create_template_options, **kwargs)  # noqa: E501

    def create_template_with_http_info(self, create_template_options, **kwargs):  # noqa: E501
        """Create a Template  # noqa: E501

        Create an email template with variables for use with templated transactional 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.create_template_with_http_info(create_template_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateTemplateOptions create_template_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(TemplateDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_template_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_template" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'create_template_options' is set
        if self.api_client.client_side_validation and ('create_template_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_template_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_template_options` when calling `create_template`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_template_options' in local_var_params:
            body_params = local_var_params['create_template_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(
            '/templates', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TemplateDto',  # 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(self, template_id, **kwargs):  # noqa: E501
        """Delete email template  # 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(template_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str template_id: Template ID (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_template_with_http_info(template_id, **kwargs)  # noqa: E501

    def delete_template_with_http_info(self, template_id, **kwargs):  # noqa: E501
        """Delete email template  # 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: 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 get_all_templates(self, **kwargs):  # noqa: E501
        """List templates  # noqa: E501

        Get all templates in paginated format  # 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_all_templates(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 in list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageTemplateProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_all_templates_with_http_info(**kwargs)  # noqa: E501

    def get_all_templates_with_http_info(self, **kwargs):  # noqa: E501
        """List templates  # noqa: E501

        Get all templates in paginated format  # 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_all_templates_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 in list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PageTemplateProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            '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 get_all_templates" % 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
        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(
            '/templates/paginated', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageTemplateProjection',  # 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_template(self, template_id, **kwargs):  # noqa: E501
        """Get template  # noqa: E501

        Get email 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.get_template(template_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str template_id: Template ID (required)
        :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: TemplateDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_template_with_http_info(template_id, **kwargs)  # noqa: E501

    def get_template_with_http_info(self, template_id, **kwargs):  # noqa: E501
        """Get template  # noqa: E501

        Get email 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.get_template_with_http_info(template_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str template_id: 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: tuple(TemplateDto, status_code(int), headers(HTTPHeaderDict))
                 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 get_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 `get_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
        # 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(
            '/templates/{templateId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TemplateDto',  # 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_template_preview_html(self, template_id, **kwargs):  # noqa: E501
        """Get template preview HTML  # noqa: E501

        Get email template preview with passed template variables in HTML format for browsers. Pass template variables as query params.  # 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_template_preview_html(template_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str template_id: Template ID (required)
        :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: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_template_preview_html_with_http_info(template_id, **kwargs)  # noqa: E501

    def get_template_preview_html_with_http_info(self, template_id, **kwargs):  # noqa: E501
        """Get template preview HTML  # noqa: E501

        Get email template preview with passed template variables in HTML format for browsers. Pass template variables as query params.  # 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_template_preview_html_with_http_info(template_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str template_id: 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: tuple(str, status_code(int), headers(HTTPHeaderDict))
                 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 get_template_preview_html" % 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 `get_template_preview_html`")  # 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
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['text/html;charset=utf-8', 'text/html'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/templates/{templateId}/preview/html', 'GET',
            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_template_preview_json(self, template_id, **kwargs):  # noqa: E501
        """Get template preview Json  # noqa: E501

        Get email template preview with passed template variables in JSON format. Pass template variables as query params.  # 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_template_preview_json(template_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str template_id: Template ID (required)
        :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: TemplatePreview
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_template_preview_json_with_http_info(template_id, **kwargs)  # noqa: E501

    def get_template_preview_json_with_http_info(self, template_id, **kwargs):  # noqa: E501
        """Get template preview Json  # noqa: E501

        Get email template preview with passed template variables in JSON format. Pass template variables as query params.  # 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_template_preview_json_with_http_info(template_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str template_id: 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: tuple(TemplatePreview, status_code(int), headers(HTTPHeaderDict))
                 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 get_template_preview_json" % 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 `get_template_preview_json`")  # 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
        # 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(
            '/templates/{templateId}/preview/json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TemplatePreview',  # 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_templates(self, **kwargs):  # noqa: E501
        """List templates  # noqa: E501

        Get all templates  # 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_templates(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: list[TemplateProjection]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_templates_with_http_info(**kwargs)  # noqa: E501

    def get_templates_with_http_info(self, **kwargs):  # noqa: E501
        """List templates  # noqa: E501

        Get all templates  # 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_templates_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(list[TemplateProjection], 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_templates" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/templates', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[TemplateProjection]',  # 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_template(self, template_id, create_template_options, **kwargs):  # noqa: E501
        """Update template  # noqa: E501

        Update email 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.update_template(template_id, create_template_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str template_id: Template ID (required)
        :param CreateTemplateOptions create_template_options: (required)
        :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: TemplateDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_template_with_http_info(template_id, create_template_options, **kwargs)  # noqa: E501

    def update_template_with_http_info(self, template_id, create_template_options, **kwargs):  # noqa: E501
        """Update template  # noqa: E501

        Update email 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.update_template_with_http_info(template_id, create_template_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str template_id: Template ID (required)
        :param CreateTemplateOptions create_template_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(TemplateDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'template_id',
            'create_template_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_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 `update_template`")  # noqa: E501
        # verify the required parameter 'create_template_options' is set
        if self.api_client.client_side_validation and ('create_template_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_template_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_template_options` when calling `update_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
        if 'create_template_options' in local_var_params:
            body_params = local_var_params['create_template_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(
            '/templates/{templateId}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TemplateDto',  # 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)

mailslurp_client/api/sms_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class SmsControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def delete_sms_message(self, sms_id, **kwargs):  # noqa: E501
        """Delete SMS message.  # noqa: E501

        Delete an SMS message  # 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_sms_message(sms_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str sms_id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_sms_message_with_http_info(sms_id, **kwargs)  # noqa: E501

    def delete_sms_message_with_http_info(self, sms_id, **kwargs):  # noqa: E501
        """Delete SMS message.  # noqa: E501

        Delete an SMS message  # 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_sms_message_with_http_info(sms_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str sms_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 = [
            'sms_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_sms_message" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'sms_id' is set
        if self.api_client.client_side_validation and ('sms_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['sms_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `sms_id` when calling `delete_sms_message`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'sms_id' in local_var_params:
            path_params['smsId'] = local_var_params['sms_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(
            '/sms/{smsId}', '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 delete_sms_messages(self, **kwargs):  # noqa: E501
        """Delete all SMS messages  # noqa: E501

        Delete all SMS messages or all messages for a given phone number  # 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_sms_messages(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id:
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_sms_messages_with_http_info(**kwargs)  # noqa: E501

    def delete_sms_messages_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all SMS messages  # noqa: E501

        Delete all SMS messages or all messages for a given phone number  # 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_sms_messages_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id:
        :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 = [
            'phone_number_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_sms_messages" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'phone_number_id' in local_var_params and local_var_params['phone_number_id'] is not None:  # noqa: E501
            query_params.append(('phoneNumberId', local_var_params['phone_number_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(
            '/sms', '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_reply_for_sms_message(self, sms_id, **kwargs):  # noqa: E501
        """Get reply for an SMS message  # noqa: E501

        Get reply for an SMS message.  # 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_reply_for_sms_message(sms_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str sms_id: (required)
        :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: ReplyForSms
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_reply_for_sms_message_with_http_info(sms_id, **kwargs)  # noqa: E501

    def get_reply_for_sms_message_with_http_info(self, sms_id, **kwargs):  # noqa: E501
        """Get reply for an SMS message  # noqa: E501

        Get reply for an SMS message.  # 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_reply_for_sms_message_with_http_info(sms_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str sms_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: tuple(ReplyForSms, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'sms_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_reply_for_sms_message" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'sms_id' is set
        if self.api_client.client_side_validation and ('sms_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['sms_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `sms_id` when calling `get_reply_for_sms_message`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'sms_id' in local_var_params:
            path_params['smsId'] = local_var_params['sms_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/sms/{smsId}/reply', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ReplyForSms',  # 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_sms_count(self, **kwargs):  # noqa: E501
        """Get SMS count  # noqa: E501

        Get number of SMS  # 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_sms_count(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: CountDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_sms_count_with_http_info(**kwargs)  # noqa: E501

    def get_sms_count_with_http_info(self, **kwargs):  # noqa: E501
        """Get SMS count  # noqa: E501

        Get number of SMS  # 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_sms_count_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(CountDto, 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_sms_count" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/sms/count', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CountDto',  # 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_sms_message(self, sms_id, **kwargs):  # noqa: E501
        """Get SMS content including body. Expects SMS to exist by ID. For SMS that may not have arrived yet use the WaitForController.  # noqa: E501

        Returns a SMS summary object with content.  # 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_sms_message(sms_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str sms_id: (required)
        :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: SmsDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_sms_message_with_http_info(sms_id, **kwargs)  # noqa: E501

    def get_sms_message_with_http_info(self, sms_id, **kwargs):  # noqa: E501
        """Get SMS content including body. Expects SMS to exist by ID. For SMS that may not have arrived yet use the WaitForController.  # noqa: E501

        Returns a SMS summary object with content.  # 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_sms_message_with_http_info(sms_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str sms_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: tuple(SmsDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'sms_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_sms_message" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'sms_id' is set
        if self.api_client.client_side_validation and ('sms_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['sms_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `sms_id` when calling `get_sms_message`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'sms_id' in local_var_params:
            path_params['smsId'] = local_var_params['sms_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/sms/{smsId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SmsDto',  # 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_sms_messages_paginated(self, **kwargs):  # noqa: E501
        """Get all SMS messages in all phone numbers in paginated form. .  # noqa: E501

        By default returns all SMS messages across all phone numbers sorted by ascending created at date. Responses are paginated. You can restrict results to a list of phone number IDs. You can also filter out read messages  # 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_sms_messages_paginated(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number: Optional receiving phone number to filter SMS messages for
        :param int page: Optional page index in SMS list pagination
        :param int size: Optional page size in SMS list pagination. Maximum size is 100. Use page index and sort to page through larger results
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param bool unread_only: Optional filter for unread SMS only. All SMS are considered unread until they are viewed in the dashboard or requested directly
        :param datetime since: Optional filter SMSs received after given date time
        :param datetime before: Optional filter SMSs received before given date time
        :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: PageSmsProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_sms_messages_paginated_with_http_info(**kwargs)  # noqa: E501

    def get_sms_messages_paginated_with_http_info(self, **kwargs):  # noqa: E501
        """Get all SMS messages in all phone numbers in paginated form. .  # noqa: E501

        By default returns all SMS messages across all phone numbers sorted by ascending created at date. Responses are paginated. You can restrict results to a list of phone number IDs. You can also filter out read messages  # 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_sms_messages_paginated_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number: Optional receiving phone number to filter SMS messages for
        :param int page: Optional page index in SMS list pagination
        :param int size: Optional page size in SMS list pagination. Maximum size is 100. Use page index and sort to page through larger results
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param bool unread_only: Optional filter for unread SMS only. All SMS are considered unread until they are viewed in the dashboard or requested directly
        :param datetime since: Optional filter SMSs received after given date time
        :param datetime before: Optional filter SMSs received before given date 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(PageSmsProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'phone_number',
            'page',
            'size',
            'sort',
            'unread_only',
            '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 get_sms_messages_paginated" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        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_sms_messages_paginated`, must be a value less than or equal to `100`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'phone_number' in local_var_params and local_var_params['phone_number'] is not None:  # noqa: E501
            query_params.append(('phoneNumber', local_var_params['phone_number']))  # 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 '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 '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
        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(
            '/sms', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageSmsProjection',  # 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_unread_sms_count(self, **kwargs):  # noqa: E501
        """Get unread SMS count  # noqa: E501

        Get number of SMS unread. Unread means has not been viewed in dashboard or returned in an email API response  # 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_unread_sms_count(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: UnreadCount
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_unread_sms_count_with_http_info(**kwargs)  # noqa: E501

    def get_unread_sms_count_with_http_info(self, **kwargs):  # noqa: E501
        """Get unread SMS count  # noqa: E501

        Get number of SMS unread. Unread means has not been viewed in dashboard or returned in an email API response  # 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_unread_sms_count_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(UnreadCount, 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_unread_sms_count" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/sms/unreadCount', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='UnreadCount',  # 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 reply_to_sms_message(self, sms_id, sms_reply_options, **kwargs):  # noqa: E501
        """Send a reply to a received SMS message. Replies are sent from the receiving number.  # noqa: E501

        Reply to an SMS message.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.reply_to_sms_message(sms_id, sms_reply_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str sms_id: (required)
        :param SmsReplyOptions sms_reply_options: (required)
        :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: SentSmsDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.reply_to_sms_message_with_http_info(sms_id, sms_reply_options, **kwargs)  # noqa: E501

    def reply_to_sms_message_with_http_info(self, sms_id, sms_reply_options, **kwargs):  # noqa: E501
        """Send a reply to a received SMS message. Replies are sent from the receiving number.  # noqa: E501

        Reply to an SMS message.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.reply_to_sms_message_with_http_info(sms_id, sms_reply_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str sms_id: (required)
        :param SmsReplyOptions sms_reply_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(SentSmsDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'sms_id',
            'sms_reply_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 reply_to_sms_message" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'sms_id' is set
        if self.api_client.client_side_validation and ('sms_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['sms_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `sms_id` when calling `reply_to_sms_message`")  # noqa: E501
        # verify the required parameter 'sms_reply_options' is set
        if self.api_client.client_side_validation and ('sms_reply_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['sms_reply_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `sms_reply_options` when calling `reply_to_sms_message`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'sms_id' in local_var_params:
            path_params['smsId'] = local_var_params['sms_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'sms_reply_options' in local_var_params:
            body_params = local_var_params['sms_reply_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(
            '/sms/{smsId}/reply', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SentSmsDto',  # 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)

mailslurp_client/api/sent_emails_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class SentEmailsControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def delete_all_sent_emails(self, **kwargs):  # noqa: E501
        """Delete all sent email receipts  # 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_all_sent_emails(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_all_sent_emails_with_http_info(**kwargs)  # noqa: E501

    def delete_all_sent_emails_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all sent email receipts  # 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_all_sent_emails_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: None
                 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 delete_all_sent_emails" % 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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/sent', '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 delete_sent_email(self, id, **kwargs):  # noqa: E501
        """Delete sent email receipt  # 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_sent_email(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_sent_email_with_http_info(id, **kwargs)  # noqa: E501

    def delete_sent_email_with_http_info(self, id, **kwargs):  # noqa: E501
        """Delete sent email receipt  # 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_sent_email_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str 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 = [
            '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_sent_email" % 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 `delete_sent_email`")  # 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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/sent/{id}', '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_all_sent_tracking_pixels(self, **kwargs):  # noqa: E501
        """get_all_sent_tracking_pixels  # noqa: E501

        Get all sent email tracking pixels in paginated form  # 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_all_sent_tracking_pixels(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index in sent email tracking pixel list pagination
        :param int size: Optional page size in sent email tracking pixel list pagination
        :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 _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: PageTrackingPixelProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_all_sent_tracking_pixels_with_http_info(**kwargs)  # noqa: E501

    def get_all_sent_tracking_pixels_with_http_info(self, **kwargs):  # noqa: E501
        """get_all_sent_tracking_pixels  # noqa: E501

        Get all sent email tracking pixels in paginated form  # 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_all_sent_tracking_pixels_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index in sent email tracking pixel list pagination
        :param int size: Optional page size in sent email tracking pixel list pagination
        :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 _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(PageTrackingPixelProjection, 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'
        ]
        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_all_sent_tracking_pixels" % 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
        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

        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(
            '/sent/tracking-pixels', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageTrackingPixelProjection',  # 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_raw_sent_email_contents(self, email_id, **kwargs):  # noqa: E501
        """Get raw sent email string. Returns unparsed raw SMTP message with headers and body.  # noqa: E501

        Returns a raw, unparsed, and unprocessed sent email. If your client has issues processing the response it is likely due to the response content-type which is text/plain. If you need a JSON response content-type use the getRawSentEmailJson endpoint  # 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_raw_sent_email_contents(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_raw_sent_email_contents_with_http_info(email_id, **kwargs)  # noqa: E501

    def get_raw_sent_email_contents_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Get raw sent email string. Returns unparsed raw SMTP message with headers and body.  # noqa: E501

        Returns a raw, unparsed, and unprocessed sent email. If your client has issues processing the response it is likely due to the response content-type which is text/plain. If you need a JSON response content-type use the getRawSentEmailJson endpoint  # 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_raw_sent_email_contents_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (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 = [
            'email_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_raw_sent_email_contents" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_raw_sent_email_contents`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_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(
            '/sent/{emailId}/raw', 'GET',
            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_raw_sent_email_json(self, email_id, **kwargs):  # noqa: E501
        """Get raw sent email in JSON. Unparsed SMTP message in JSON wrapper format.  # noqa: E501

        Returns a raw, unparsed, and unprocessed sent email wrapped in a JSON response object for easier handling when compared with the getRawSentEmail text/plain response  # 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_raw_sent_email_json(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (required)
        :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: RawEmailJson
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_raw_sent_email_json_with_http_info(email_id, **kwargs)  # noqa: E501

    def get_raw_sent_email_json_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Get raw sent email in JSON. Unparsed SMTP message in JSON wrapper format.  # noqa: E501

        Returns a raw, unparsed, and unprocessed sent email wrapped in a JSON response object for easier handling when compared with the getRawSentEmail text/plain response  # 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_raw_sent_email_json_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (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(RawEmailJson, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_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_raw_sent_email_json" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_raw_sent_email_json`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/sent/{emailId}/raw/json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='RawEmailJson',  # 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_sent_delivery_status(self, delivery_id, **kwargs):  # noqa: E501
        """get_sent_delivery_status  # noqa: E501

        Get a sent email delivery status  # 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_sent_delivery_status(delivery_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str delivery_id: (required)
        :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: DeliveryStatusDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_sent_delivery_status_with_http_info(delivery_id, **kwargs)  # noqa: E501

    def get_sent_delivery_status_with_http_info(self, delivery_id, **kwargs):  # noqa: E501
        """get_sent_delivery_status  # noqa: E501

        Get a sent email delivery status  # 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_sent_delivery_status_with_http_info(delivery_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str delivery_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: tuple(DeliveryStatusDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'delivery_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_sent_delivery_status" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'delivery_id' is set
        if self.api_client.client_side_validation and ('delivery_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['delivery_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `delivery_id` when calling `get_sent_delivery_status`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'delivery_id' in local_var_params:
            path_params['deliveryId'] = local_var_params['delivery_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/sent/delivery-status/{deliveryId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DeliveryStatusDto',  # 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_sent_delivery_statuses(self, **kwargs):  # noqa: E501
        """get_sent_delivery_statuses  # noqa: E501

        Get all sent email delivery statuses  # 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_sent_delivery_statuses(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index in delivery status list pagination
        :param int size: Optional page size in delivery status list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageDeliveryStatus
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_sent_delivery_statuses_with_http_info(**kwargs)  # noqa: E501

    def get_sent_delivery_statuses_with_http_info(self, **kwargs):  # noqa: E501
        """get_sent_delivery_statuses  # noqa: E501

        Get all sent email delivery statuses  # 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_sent_delivery_statuses_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index in delivery status list pagination
        :param int size: Optional page size in delivery status list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PageDeliveryStatus, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            '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 get_sent_delivery_statuses" % 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
        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(
            '/sent/delivery-status', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageDeliveryStatus',  # 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_sent_delivery_statuses_by_sent_id(self, sent_id, **kwargs):  # noqa: E501
        """get_sent_delivery_statuses_by_sent_id  # noqa: E501

        Get all sent email delivery statuses  # 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_sent_delivery_statuses_by_sent_id(sent_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str sent_id: ID of the sent email that you want to get the delivery status of. Sent email object is returned when sending an email (required)
        :param int page: Optional page index in delivery status list pagination
        :param int size: Optional page size in delivery status list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageDeliveryStatus
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_sent_delivery_statuses_by_sent_id_with_http_info(sent_id, **kwargs)  # noqa: E501

    def get_sent_delivery_statuses_by_sent_id_with_http_info(self, sent_id, **kwargs):  # noqa: E501
        """get_sent_delivery_statuses_by_sent_id  # noqa: E501

        Get all sent email delivery statuses  # 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_sent_delivery_statuses_by_sent_id_with_http_info(sent_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str sent_id: ID of the sent email that you want to get the delivery status of. Sent email object is returned when sending an email (required)
        :param int page: Optional page index in delivery status list pagination
        :param int size: Optional page size in delivery status list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PageDeliveryStatus, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'sent_id',
            'page',
            'size',
            'sort',
            '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 get_sent_delivery_statuses_by_sent_id" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'sent_id' is set
        if self.api_client.client_side_validation and ('sent_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['sent_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `sent_id` when calling `get_sent_delivery_statuses_by_sent_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'sent_id' in local_var_params:
            path_params['sentId'] = local_var_params['sent_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
        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(
            '/sent/{sentId}/delivery-status', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageDeliveryStatus',  # 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_sent_email(self, id, **kwargs):  # noqa: E501
        """Get sent email receipt  # 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_sent_email(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :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: SentEmailDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_sent_email_with_http_info(id, **kwargs)  # noqa: E501

    def get_sent_email_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get sent email receipt  # 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_sent_email_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str 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: tuple(SentEmailDto, 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_sent_email" % 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_sent_email`")  # 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/sent/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SentEmailDto',  # 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_sent_email_html_content(self, id, **kwargs):  # noqa: E501
        """Get sent email HTML content  # 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_sent_email_html_content(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :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: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_sent_email_html_content_with_http_info(id, **kwargs)  # noqa: E501

    def get_sent_email_html_content_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get sent email HTML content  # 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_sent_email_html_content_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str 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: tuple(str, 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_sent_email_html_content" % 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_sent_email_html_content`")  # 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(
            ['text/html'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/sent/{id}/html', 'GET',
            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_sent_email_preview_ur_ls(self, id, **kwargs):  # noqa: E501
        """Get sent email URL for viewing in browser or downloading  # noqa: E501

        Get a list of URLs for sent email content as text/html or raw SMTP message for viewing the message in a 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.get_sent_email_preview_ur_ls(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :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: EmailPreviewUrls
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_sent_email_preview_ur_ls_with_http_info(id, **kwargs)  # noqa: E501

    def get_sent_email_preview_ur_ls_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get sent email URL for viewing in browser or downloading  # noqa: E501

        Get a list of URLs for sent email content as text/html or raw SMTP message for viewing the message in a 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.get_sent_email_preview_ur_ls_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str 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: tuple(EmailPreviewUrls, 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_sent_email_preview_ur_ls" % 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_sent_email_preview_ur_ls`")  # 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/sent/{id}/urls', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmailPreviewUrls',  # 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_sent_email_tracking_pixels(self, id, **kwargs):  # noqa: E501
        """get_sent_email_tracking_pixels  # noqa: E501

        Get all tracking pixels for a sent email in paginated form  # 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_sent_email_tracking_pixels(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param int page: Optional page index in sent email tracking pixel list pagination
        :param int size: Optional page size in sent email tracking pixel list pagination
        :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 _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: PageTrackingPixelProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_sent_email_tracking_pixels_with_http_info(id, **kwargs)  # noqa: E501

    def get_sent_email_tracking_pixels_with_http_info(self, id, **kwargs):  # noqa: E501
        """get_sent_email_tracking_pixels  # noqa: E501

        Get all tracking pixels for a sent email in paginated form  # 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_sent_email_tracking_pixels_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param int page: Optional page index in sent email tracking pixel list pagination
        :param int size: Optional page size in sent email tracking pixel list pagination
        :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 _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(PageTrackingPixelProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'id',
            'page',
            'size',
            'sort',
            'search_filter',
            '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 get_sent_email_tracking_pixels" % 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_sent_email_tracking_pixels`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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
        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

        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(
            '/sent/{id}/tracking-pixels', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageTrackingPixelProjection',  # 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_sent_emails(self, **kwargs):  # noqa: E501
        """Get all sent emails in paginated form  # 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_sent_emails(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Optional inboxId to filter sender of sent emails by
        :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 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 _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: PageSentEmailProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_sent_emails_with_http_info(**kwargs)  # noqa: E501

    def get_sent_emails_with_http_info(self, **kwargs):  # noqa: E501
        """Get all sent emails in paginated form  # 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_sent_emails_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Optional inboxId to filter sender of sent emails by
        :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 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 _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(PageSentEmailProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort',
            'search_filter',
            '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 get_sent_emails" % 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 '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

        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(
            '/sent', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageSentEmailProjection',  # 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_sent_emails_with_queue_results(self, **kwargs):  # noqa: E501
        """Get results of email sent with queues in paginated form  # 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_sent_emails_with_queue_results(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 datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageSentEmailWithQueueProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_sent_emails_with_queue_results_with_http_info(**kwargs)  # noqa: E501

    def get_sent_emails_with_queue_results_with_http_info(self, **kwargs):  # noqa: E501
        """Get results of email sent with queues in paginated form  # 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_sent_emails_with_queue_results_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 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(PageSentEmailWithQueueProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            '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 get_sent_emails_with_queue_results" % 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
        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(
            '/sent/queue-results', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageSentEmailWithQueueProjection',  # 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_sent_organization_emails(self, **kwargs):  # noqa: E501
        """get_sent_organization_emails  # noqa: E501

        Get all sent organization emails in paginated form  # 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_sent_organization_emails(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Optional inboxId to filter sender of sent emails by
        :param int page: Optional page index in sent email list pagination
        :param int size: Optional page size in sent email list pagination
        :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 _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: PageSentEmailProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_sent_organization_emails_with_http_info(**kwargs)  # noqa: E501

    def get_sent_organization_emails_with_http_info(self, **kwargs):  # noqa: E501
        """get_sent_organization_emails  # noqa: E501

        Get all sent organization emails in paginated form  # 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_sent_organization_emails_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Optional inboxId to filter sender of sent emails by
        :param int page: Optional page index in sent email list pagination
        :param int size: Optional page size in sent email list pagination
        :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 _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(PageSentEmailProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort',
            'search_filter',
            '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 get_sent_organization_emails" % 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 '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

        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(
            '/sent/organization', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageSentEmailProjection',  # 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_delivery_statuses(self, **kwargs):  # noqa: E501
        """wait_for_delivery_statuses  # noqa: E501

        Wait for delivery statuses  # 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_delivery_statuses(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str sent_id: Optional sent email ID filter
        :param str inbox_id: Optional inbox ID filter
        :param int timeout: Optional timeout milliseconds
        :param int index: Zero based index of the delivery status to wait for. If 1 delivery status already and you want to wait for the 2nd pass index=1
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: DeliveryStatusDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.wait_for_delivery_statuses_with_http_info(**kwargs)  # noqa: E501

    def wait_for_delivery_statuses_with_http_info(self, **kwargs):  # noqa: E501
        """wait_for_delivery_statuses  # noqa: E501

        Wait for delivery statuses  # 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_delivery_statuses_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str sent_id: Optional sent email ID filter
        :param str inbox_id: Optional inbox ID filter
        :param int timeout: Optional timeout milliseconds
        :param int index: Zero based index of the delivery status to wait for. If 1 delivery status already and you want to wait for the 2nd pass index=1
        :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(DeliveryStatusDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'sent_id',
            'inbox_id',
            'timeout',
            'index',
            '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_delivery_statuses" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        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_delivery_statuses`, 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_delivery_statuses`, must be a value greater than or equal to `0`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'sent_id' in local_var_params and local_var_params['sent_id'] is not None:  # noqa: E501
            query_params.append(('sentId', local_var_params['sent_id']))  # 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 '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(
            '/sent/delivery-status/wait-for', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DeliveryStatusDto',  # 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)

mailslurp_client/api/phone_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class PhoneControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def create_emergency_address(self, create_emergency_address_options, **kwargs):  # noqa: E501
        """create_emergency_address  # 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_emergency_address(create_emergency_address_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateEmergencyAddressOptions create_emergency_address_options: (required)
        :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: EmergencyAddress
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_emergency_address_with_http_info(create_emergency_address_options, **kwargs)  # noqa: E501

    def create_emergency_address_with_http_info(self, create_emergency_address_options, **kwargs):  # noqa: E501
        """create_emergency_address  # 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_emergency_address_with_http_info(create_emergency_address_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateEmergencyAddressOptions create_emergency_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(EmergencyAddress, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_emergency_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 create_emergency_address" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'create_emergency_address_options' is set
        if self.api_client.client_side_validation and ('create_emergency_address_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_emergency_address_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_emergency_address_options` when calling `create_emergency_address`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_emergency_address_options' in local_var_params:
            body_params = local_var_params['create_emergency_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(
            '/phone/emergency-addresses', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmergencyAddress',  # 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_emergency_address(self, address_id, **kwargs):  # noqa: E501
        """delete_emergency_address  # 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_emergency_address(address_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str address_id: (required)
        :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: EmptyResponseDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_emergency_address_with_http_info(address_id, **kwargs)  # noqa: E501

    def delete_emergency_address_with_http_info(self, address_id, **kwargs):  # noqa: E501
        """delete_emergency_address  # 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_emergency_address_with_http_info(address_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str address_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: tuple(EmptyResponseDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'address_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_emergency_address" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'address_id' is set
        if self.api_client.client_side_validation and ('address_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['address_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `address_id` when calling `delete_emergency_address`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'address_id' in local_var_params:
            path_params['addressId'] = local_var_params['address_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/phone/emergency-addresses/{addressId}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmptyResponseDto',  # 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_phone_number(self, phone_number_id, **kwargs):  # noqa: E501
        """delete_phone_number  # 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_phone_number(phone_number_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_phone_number_with_http_info(phone_number_id, **kwargs)  # noqa: E501

    def delete_phone_number_with_http_info(self, phone_number_id, **kwargs):  # noqa: E501
        """delete_phone_number  # 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_phone_number_with_http_info(phone_number_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_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 = [
            'phone_number_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_phone_number" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'phone_number_id' is set
        if self.api_client.client_side_validation and ('phone_number_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['phone_number_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `phone_number_id` when calling `delete_phone_number`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'phone_number_id' in local_var_params:
            path_params['phoneNumberId'] = local_var_params['phone_number_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(
            '/phone/numbers/{phoneNumberId}', '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_emergency_address(self, address_id, **kwargs):  # noqa: E501
        """get_emergency_address  # 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_emergency_address(address_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str address_id: (required)
        :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: EmergencyAddress
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_emergency_address_with_http_info(address_id, **kwargs)  # noqa: E501

    def get_emergency_address_with_http_info(self, address_id, **kwargs):  # noqa: E501
        """get_emergency_address  # 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_emergency_address_with_http_info(address_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str address_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: tuple(EmergencyAddress, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'address_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_emergency_address" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'address_id' is set
        if self.api_client.client_side_validation and ('address_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['address_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `address_id` when calling `get_emergency_address`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'address_id' in local_var_params:
            path_params['addressId'] = local_var_params['address_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/phone/emergency-addresses/{addressId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmergencyAddress',  # 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_emergency_addresses(self, **kwargs):  # noqa: E501
        """get_emergency_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.get_emergency_addresses(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: list[EmergencyAddressDto]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_emergency_addresses_with_http_info(**kwargs)  # noqa: E501

    def get_emergency_addresses_with_http_info(self, **kwargs):  # noqa: E501
        """get_emergency_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.get_emergency_addresses_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(list[EmergencyAddressDto], 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_emergency_addresses" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/phone/emergency-addresses', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[EmergencyAddressDto]',  # 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_phone_number(self, phone_number_id, **kwargs):  # noqa: E501
        """get_phone_number  # 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_phone_number(phone_number_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :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: PhoneNumberDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_phone_number_with_http_info(phone_number_id, **kwargs)  # noqa: E501

    def get_phone_number_with_http_info(self, phone_number_id, **kwargs):  # noqa: E501
        """get_phone_number  # 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_phone_number_with_http_info(phone_number_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_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: tuple(PhoneNumberDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'phone_number_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_phone_number" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'phone_number_id' is set
        if self.api_client.client_side_validation and ('phone_number_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['phone_number_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `phone_number_id` when calling `get_phone_number`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'phone_number_id' in local_var_params:
            path_params['phoneNumberId'] = local_var_params['phone_number_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/phone/numbers/{phoneNumberId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PhoneNumberDto',  # 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_phone_numbers(self, **kwargs):  # noqa: E501
        """get_phone_numbers  # 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_phone_numbers(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_country: Optional phone country
        :param int page: Optional page index for list pagination
        :param int size: Optional page size for list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PagePhoneNumberProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_phone_numbers_with_http_info(**kwargs)  # noqa: E501

    def get_phone_numbers_with_http_info(self, **kwargs):  # noqa: E501
        """get_phone_numbers  # 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_phone_numbers_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_country: Optional phone country
        :param int page: Optional page index for list pagination
        :param int size: Optional page size for list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PagePhoneNumberProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'phone_country',
            'page',
            'size',
            'sort',
            '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 get_phone_numbers" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'phone_country' in local_var_params and local_var_params['phone_country'] is not None:  # noqa: E501
            query_params.append(('phoneCountry', local_var_params['phone_country']))  # 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 '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 '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(
            '/phone/numbers', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PagePhoneNumberProjection',  # 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_phone_plans(self, **kwargs):  # noqa: E501
        """get_phone_plans  # 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_phone_plans(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: list[PhonePlanDto]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_phone_plans_with_http_info(**kwargs)  # noqa: E501

    def get_phone_plans_with_http_info(self, **kwargs):  # noqa: E501
        """get_phone_plans  # 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_phone_plans_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(list[PhonePlanDto], 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_phone_plans" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/phone/plans', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[PhonePlanDto]',  # 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 test_phone_number_send_sms(self, phone_number_id, test_phone_number_options, **kwargs):  # noqa: E501
        """test_phone_number_send_sms  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.test_phone_number_send_sms(phone_number_id, test_phone_number_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param TestPhoneNumberOptions test_phone_number_options: (required)
        :param str x_test_id:
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.test_phone_number_send_sms_with_http_info(phone_number_id, test_phone_number_options, **kwargs)  # noqa: E501

    def test_phone_number_send_sms_with_http_info(self, phone_number_id, test_phone_number_options, **kwargs):  # noqa: E501
        """test_phone_number_send_sms  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.test_phone_number_send_sms_with_http_info(phone_number_id, test_phone_number_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param TestPhoneNumberOptions test_phone_number_options: (required)
        :param str x_test_id:
        :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 = [
            'phone_number_id',
            'test_phone_number_options',
            'x_test_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 test_phone_number_send_sms" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'phone_number_id' is set
        if self.api_client.client_side_validation and ('phone_number_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['phone_number_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `phone_number_id` when calling `test_phone_number_send_sms`")  # noqa: E501
        # verify the required parameter 'test_phone_number_options' is set
        if self.api_client.client_side_validation and ('test_phone_number_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['test_phone_number_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `test_phone_number_options` when calling `test_phone_number_send_sms`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'phone_number_id' in local_var_params:
            path_params['phoneNumberId'] = local_var_params['phone_number_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'x_test_id' in local_var_params:
            header_params['x-test-id'] = local_var_params['x_test_id']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'test_phone_number_options' in local_var_params:
            body_params = local_var_params['test_phone_number_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(
            '/phone/numbers/{phoneNumberId}/test', '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)

mailslurp_client/api/missed_email_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class MissedEmailControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def get_all_missed_emails(self, **kwargs):  # noqa: E501
        """Get all MissedEmails in paginated format  # 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_all_missed_emails(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 in list pagination
        :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 str inbox_id: Optional inbox ID filter
        :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: PageMissedEmailProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_all_missed_emails_with_http_info(**kwargs)  # noqa: E501

    def get_all_missed_emails_with_http_info(self, **kwargs):  # noqa: E501
        """Get all MissedEmails in paginated format  # 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_all_missed_emails_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 in list pagination
        :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 str inbox_id: Optional inbox ID filter
        :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(PageMissedEmailProjection, 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',
            '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 get_all_missed_emails" % 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
        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 '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
        # 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', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageMissedEmailProjection',  # 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_all_unknown_missed_emails(self, **kwargs):  # noqa: E501
        """Get all unknown missed emails in paginated format  # noqa: E501

        Unknown missed emails are emails that were sent to MailSlurp but could not be assigned to an existing 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_all_unknown_missed_emails(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 in list pagination
        :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 str inbox_id: Optional inbox ID filter
        :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: PageUnknownMissedEmailProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_all_unknown_missed_emails_with_http_info(**kwargs)  # noqa: E501

    def get_all_unknown_missed_emails_with_http_info(self, **kwargs):  # noqa: E501
        """Get all unknown missed emails in paginated format  # noqa: E501

        Unknown missed emails are emails that were sent to MailSlurp but could not be assigned to an existing 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_all_unknown_missed_emails_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 in list pagination
        :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 str inbox_id: Optional inbox ID filter
        :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(PageUnknownMissedEmailProjection, 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',
            '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 get_all_unknown_missed_emails" % 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
        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 '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
        # 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/unknown', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageUnknownMissedEmailProjection',  # 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_missed_email(self, missed_email_id, **kwargs):  # noqa: E501
        """Get MissedEmail  # noqa: E501

        List emails that were missed due to plan limits.  # 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_missed_email(missed_email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str missed_email_id: (required)
        :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: MissedEmailDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_missed_email_with_http_info(missed_email_id, **kwargs)  # noqa: E501

    def get_missed_email_with_http_info(self, missed_email_id, **kwargs):  # noqa: E501
        """Get MissedEmail  # noqa: E501

        List emails that were missed due to plan limits.  # 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_missed_email_with_http_info(missed_email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str missed_email_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: tuple(MissedEmailDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'missed_email_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_missed_email" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'missed_email_id' is set
        if self.api_client.client_side_validation and ('missed_email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['missed_email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `missed_email_id` when calling `get_missed_email`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'missed_email_id' in local_var_params:
            path_params['missedEmailId'] = local_var_params['missed_email_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/missed-emails/{missedEmailId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='MissedEmailDto',  # 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 restore_missed_emails(self, **kwargs):  # noqa: E501
        """Restore missed emails  # noqa: E501

        If emails were missed due to a plan limit they are saved as missed emails. If support team enables the canRestore flag these emails can be reload into your account using this 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.restore_missed_emails(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.restore_missed_emails_with_http_info(**kwargs)  # noqa: E501

    def restore_missed_emails_with_http_info(self, **kwargs):  # noqa: E501
        """Restore missed emails  # noqa: E501

        If emails were missed due to a plan limit they are saved as missed emails. If support team enables the canRestore flag these emails can be reload into your account using this 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.restore_missed_emails_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: None
                 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 restore_missed_emails" % 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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/missed-emails/restore', '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 wait_for_nth_missed_email(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(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 _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: MissedEmailDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.wait_for_nth_missed_email_with_http_info(index, **kwargs)  # noqa: E501

    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(MissedEmailDto, 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='MissedEmailDto',  # 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)

mailslurp_client/api/mail_server_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class MailServerControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def describe_mail_server_domain(self, describe_domain_options, **kwargs):  # noqa: E501
        """Get DNS Mail Server records for a 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.describe_mail_server_domain(describe_domain_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param DescribeDomainOptions describe_domain_options: (required)
        :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: DescribeMailServerDomainResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.describe_mail_server_domain_with_http_info(describe_domain_options, **kwargs)  # noqa: E501

    def describe_mail_server_domain_with_http_info(self, describe_domain_options, **kwargs):  # noqa: E501
        """Get DNS Mail Server records for a 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.describe_mail_server_domain_with_http_info(describe_domain_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param DescribeDomainOptions describe_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(DescribeMailServerDomainResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'describe_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 describe_mail_server_domain" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'describe_domain_options' is set
        if self.api_client.client_side_validation and ('describe_domain_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['describe_domain_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `describe_domain_options` when calling `describe_mail_server_domain`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'describe_domain_options' in local_var_params:
            body_params = local_var_params['describe_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(
            '/mail-server/describe/domain', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DescribeMailServerDomainResult',  # 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_dns_lookup(self, dns_lookup_options, **kwargs):  # noqa: E501
        """Lookup DNS records for a 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.get_dns_lookup(dns_lookup_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param DNSLookupOptions dns_lookup_options: (required)
        :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: DNSLookupResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_dns_lookup_with_http_info(dns_lookup_options, **kwargs)  # noqa: E501

    def get_dns_lookup_with_http_info(self, dns_lookup_options, **kwargs):  # noqa: E501
        """Lookup DNS records for a 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.get_dns_lookup_with_http_info(dns_lookup_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param DNSLookupOptions dns_lookup_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(DNSLookupResults, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'dns_lookup_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 get_dns_lookup" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'dns_lookup_options' is set
        if self.api_client.client_side_validation and ('dns_lookup_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['dns_lookup_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `dns_lookup_options` when calling `get_dns_lookup`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'dns_lookup_options' in local_var_params:
            body_params = local_var_params['dns_lookup_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/describe/dns-lookup', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DNSLookupResults',  # 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_dns_lookups(self, dns_lookups_options, **kwargs):  # noqa: E501
        """Lookup DNS records for multiple domains  # 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_dns_lookups(dns_lookups_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param DNSLookupsOptions dns_lookups_options: (required)
        :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: DNSLookupResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_dns_lookups_with_http_info(dns_lookups_options, **kwargs)  # noqa: E501

    def get_dns_lookups_with_http_info(self, dns_lookups_options, **kwargs):  # noqa: E501
        """Lookup DNS records for multiple domains  # 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_dns_lookups_with_http_info(dns_lookups_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param DNSLookupsOptions dns_lookups_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(DNSLookupResults, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'dns_lookups_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 get_dns_lookups" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'dns_lookups_options' is set
        if self.api_client.client_side_validation and ('dns_lookups_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['dns_lookups_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `dns_lookups_options` when calling `get_dns_lookups`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'dns_lookups_options' in local_var_params:
            body_params = local_var_params['dns_lookups_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/describe/dns-lookups', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DNSLookupResults',  # 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_ip_address(self, name, **kwargs):  # noqa: E501
        """Get IP address for a 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.get_ip_address(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str name: (required)
        :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: IPAddressResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_ip_address_with_http_info(name, **kwargs)  # noqa: E501

    def get_ip_address_with_http_info(self, name, **kwargs):  # noqa: E501
        """Get IP address for a 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.get_ip_address_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str name: (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(IPAddressResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'name'
        ]
        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_ip_address" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'name' is set
        if self.api_client.client_side_validation and ('name' not in local_var_params or  # noqa: E501
                                                        local_var_params['name'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `name` when calling `get_ip_address`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'name' in local_var_params and local_var_params['name'] is not None:  # noqa: E501
            query_params.append(('name', local_var_params['name']))  # 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(
            '/mail-server/describe/ip-address', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='IPAddressResult',  # 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(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(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 _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: EmailVerificationResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.verify_email_address_with_http_info(verify_email_address_options, **kwargs)  # noqa: E501

    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)

mailslurp_client/api/inbox_ruleset_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class InboxRulesetControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def create_new_inbox_ruleset(self, create_inbox_ruleset_options, **kwargs):  # noqa: E501
        """Create an inbox ruleset  # 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_ruleset(create_inbox_ruleset_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateInboxRulesetOptions create_inbox_ruleset_options: (required)
        :param str inbox_id: Inbox id to attach ruleset to
        :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: InboxRulesetDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_new_inbox_ruleset_with_http_info(create_inbox_ruleset_options, **kwargs)  # noqa: E501

    def create_new_inbox_ruleset_with_http_info(self, create_inbox_ruleset_options, **kwargs):  # noqa: E501
        """Create an inbox ruleset  # 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_ruleset_with_http_info(create_inbox_ruleset_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateInboxRulesetOptions create_inbox_ruleset_options: (required)
        :param str inbox_id: Inbox id to attach ruleset 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(InboxRulesetDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_inbox_ruleset_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_ruleset" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'create_inbox_ruleset_options' is set
        if self.api_client.client_side_validation and ('create_inbox_ruleset_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_inbox_ruleset_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_inbox_ruleset_options` when calling `create_new_inbox_ruleset`")  # 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_ruleset_options' in local_var_params:
            body_params = local_var_params['create_inbox_ruleset_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(
            '/rulesets', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxRulesetDto',  # 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_ruleset(self, id, **kwargs):  # noqa: E501
        """Delete an inbox ruleset  # noqa: E501

        Delete 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.delete_inbox_ruleset(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox ruleset (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_inbox_ruleset_with_http_info(id, **kwargs)  # noqa: E501

    def delete_inbox_ruleset_with_http_info(self, id, **kwargs):  # noqa: E501
        """Delete an inbox ruleset  # noqa: E501

        Delete 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.delete_inbox_ruleset_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox ruleset (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 = [
            '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_ruleset" % 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 `delete_inbox_ruleset`")  # 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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/rulesets/{id}', '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 delete_inbox_rulesets(self, **kwargs):  # noqa: E501
        """Delete inbox rulesets  # noqa: E501

        Delete inbox rulesets. 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_rulesets(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Optional inbox id to attach ruleset to
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_inbox_rulesets_with_http_info(**kwargs)  # noqa: E501

    def delete_inbox_rulesets_with_http_info(self, **kwargs):  # noqa: E501
        """Delete inbox rulesets  # noqa: E501

        Delete inbox rulesets. 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_rulesets_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 ruleset 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_rulesets" % 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(
            '/rulesets', '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_ruleset(self, id, **kwargs):  # noqa: E501
        """Get an inbox ruleset  # 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_ruleset(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox ruleset (required)
        :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: InboxRulesetDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_ruleset_with_http_info(id, **kwargs)  # noqa: E501

    def get_inbox_ruleset_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get an inbox ruleset  # 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_ruleset_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox ruleset (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(InboxRulesetDto, 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_ruleset" % 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_ruleset`")  # 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/rulesets/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxRulesetDto',  # 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_rulesets(self, **kwargs):  # noqa: E501
        """List inbox rulesets  # noqa: E501

        List all rulesets 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_rulesets(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Optional inbox id to get rulesets from
        :param int page: Optional page index in inbox ruleset list pagination
        :param int size: Optional page size in inbox ruleset list pagination
        :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 _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: PageInboxRulesetDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_rulesets_with_http_info(**kwargs)  # noqa: E501

    def get_inbox_rulesets_with_http_info(self, **kwargs):  # noqa: E501
        """List inbox rulesets  # noqa: E501

        List all rulesets 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_rulesets_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 rulesets from
        :param int page: Optional page index in inbox ruleset list pagination
        :param int size: Optional page size in inbox ruleset list pagination
        :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 _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(PageInboxRulesetDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort',
            'search_filter',
            '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 get_inbox_rulesets" % 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 '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

        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(
            '/rulesets', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageInboxRulesetDto',  # 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 test_inbox_ruleset(self, id, inbox_ruleset_test_options, **kwargs):  # noqa: E501
        """Test an inbox ruleset  # noqa: E501

        Test an 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.test_inbox_ruleset(id, inbox_ruleset_test_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox ruleset (required)
        :param InboxRulesetTestOptions inbox_ruleset_test_options: (required)
        :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: InboxRulesetTestResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.test_inbox_ruleset_with_http_info(id, inbox_ruleset_test_options, **kwargs)  # noqa: E501

    def test_inbox_ruleset_with_http_info(self, id, inbox_ruleset_test_options, **kwargs):  # noqa: E501
        """Test an inbox ruleset  # noqa: E501

        Test an 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.test_inbox_ruleset_with_http_info(id, inbox_ruleset_test_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox ruleset (required)
        :param InboxRulesetTestOptions inbox_ruleset_test_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(InboxRulesetTestResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'id',
            'inbox_ruleset_test_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 test_inbox_ruleset" % 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 `test_inbox_ruleset`")  # noqa: E501
        # verify the required parameter 'inbox_ruleset_test_options' is set
        if self.api_client.client_side_validation and ('inbox_ruleset_test_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_ruleset_test_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_ruleset_test_options` when calling `test_inbox_ruleset`")  # 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 'inbox_ruleset_test_options' in local_var_params:
            body_params = local_var_params['inbox_ruleset_test_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(
            '/rulesets/{id}/test', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxRulesetTestResult',  # 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 test_inbox_ruleset_receiving(self, test_inbox_ruleset_receiving_options, **kwargs):  # noqa: E501
        """Test receiving with inbox rulesets  # noqa: E501

        Test whether inbound emails from an email address would be blocked or allowed by inbox rulesets  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.test_inbox_ruleset_receiving(test_inbox_ruleset_receiving_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param TestInboxRulesetReceivingOptions test_inbox_ruleset_receiving_options: (required)
        :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: TestInboxRulesetReceivingResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.test_inbox_ruleset_receiving_with_http_info(test_inbox_ruleset_receiving_options, **kwargs)  # noqa: E501

    def test_inbox_ruleset_receiving_with_http_info(self, test_inbox_ruleset_receiving_options, **kwargs):  # noqa: E501
        """Test receiving with inbox rulesets  # noqa: E501

        Test whether inbound emails from an email address would be blocked or allowed by inbox rulesets  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.test_inbox_ruleset_receiving_with_http_info(test_inbox_ruleset_receiving_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param TestInboxRulesetReceivingOptions test_inbox_ruleset_receiving_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(TestInboxRulesetReceivingResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'test_inbox_ruleset_receiving_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 test_inbox_ruleset_receiving" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'test_inbox_ruleset_receiving_options' is set
        if self.api_client.client_side_validation and ('test_inbox_ruleset_receiving_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['test_inbox_ruleset_receiving_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `test_inbox_ruleset_receiving_options` when calling `test_inbox_ruleset_receiving`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'test_inbox_ruleset_receiving_options' in local_var_params:
            body_params = local_var_params['test_inbox_ruleset_receiving_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(
            '/rulesets/test-receiving', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TestInboxRulesetReceivingResult',  # 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 test_inbox_ruleset_sending(self, test_inbox_ruleset_sending_options, **kwargs):  # noqa: E501
        """Test sending with inbox rulesets  # noqa: E501

        Test whether outbound emails to an email address would be blocked or allowed by inbox rulesets  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.test_inbox_ruleset_sending(test_inbox_ruleset_sending_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param TestInboxRulesetSendingOptions test_inbox_ruleset_sending_options: (required)
        :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: TestInboxRulesetSendingResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.test_inbox_ruleset_sending_with_http_info(test_inbox_ruleset_sending_options, **kwargs)  # noqa: E501

    def test_inbox_ruleset_sending_with_http_info(self, test_inbox_ruleset_sending_options, **kwargs):  # noqa: E501
        """Test sending with inbox rulesets  # noqa: E501

        Test whether outbound emails to an email address would be blocked or allowed by inbox rulesets  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.test_inbox_ruleset_sending_with_http_info(test_inbox_ruleset_sending_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param TestInboxRulesetSendingOptions test_inbox_ruleset_sending_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(TestInboxRulesetSendingResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'test_inbox_ruleset_sending_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 test_inbox_ruleset_sending" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'test_inbox_ruleset_sending_options' is set
        if self.api_client.client_side_validation and ('test_inbox_ruleset_sending_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['test_inbox_ruleset_sending_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `test_inbox_ruleset_sending_options` when calling `test_inbox_ruleset_sending`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'test_inbox_ruleset_sending_options' in local_var_params:
            body_params = local_var_params['test_inbox_ruleset_sending_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(
            '/rulesets/test-sending', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TestInboxRulesetSendingResult',  # 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 test_inbox_rulesets_for_inbox(self, inbox_id, inbox_ruleset_test_options, **kwargs):  # noqa: E501
        """Test inbox rulesets for inbox  # noqa: E501

        Test inbox rulesets for 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.test_inbox_rulesets_for_inbox(inbox_id, inbox_ruleset_test_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox (required)
        :param InboxRulesetTestOptions inbox_ruleset_test_options: (required)
        :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: InboxRulesetTestResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.test_inbox_rulesets_for_inbox_with_http_info(inbox_id, inbox_ruleset_test_options, **kwargs)  # noqa: E501

    def test_inbox_rulesets_for_inbox_with_http_info(self, inbox_id, inbox_ruleset_test_options, **kwargs):  # noqa: E501
        """Test inbox rulesets for inbox  # noqa: E501

        Test inbox rulesets for 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.test_inbox_rulesets_for_inbox_with_http_info(inbox_id, inbox_ruleset_test_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox (required)
        :param InboxRulesetTestOptions inbox_ruleset_test_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(InboxRulesetTestResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'inbox_ruleset_test_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 test_inbox_rulesets_for_inbox" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `test_inbox_rulesets_for_inbox`")  # noqa: E501
        # verify the required parameter 'inbox_ruleset_test_options' is set
        if self.api_client.client_side_validation and ('inbox_ruleset_test_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_ruleset_test_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_ruleset_test_options` when calling `test_inbox_rulesets_for_inbox`")  # 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 'inbox_ruleset_test_options' in local_var_params:
            body_params = local_var_params['inbox_ruleset_test_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(
            '/rulesets', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxRulesetTestResult',  # 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 test_new_inbox_ruleset(self, test_new_inbox_ruleset_options, **kwargs):  # noqa: E501
        """Test new inbox ruleset  # noqa: E501

        Test new 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.test_new_inbox_ruleset(test_new_inbox_ruleset_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param TestNewInboxRulesetOptions test_new_inbox_ruleset_options: (required)
        :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: InboxRulesetTestResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.test_new_inbox_ruleset_with_http_info(test_new_inbox_ruleset_options, **kwargs)  # noqa: E501

    def test_new_inbox_ruleset_with_http_info(self, test_new_inbox_ruleset_options, **kwargs):  # noqa: E501
        """Test new inbox ruleset  # noqa: E501

        Test new 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.test_new_inbox_ruleset_with_http_info(test_new_inbox_ruleset_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param TestNewInboxRulesetOptions test_new_inbox_ruleset_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(InboxRulesetTestResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'test_new_inbox_ruleset_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 test_new_inbox_ruleset" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'test_new_inbox_ruleset_options' is set
        if self.api_client.client_side_validation and ('test_new_inbox_ruleset_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['test_new_inbox_ruleset_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `test_new_inbox_ruleset_options` when calling `test_new_inbox_ruleset`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'test_new_inbox_ruleset_options' in local_var_params:
            body_params = local_var_params['test_new_inbox_ruleset_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(
            '/rulesets', 'PATCH',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxRulesetTestResult',  # 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)

mailslurp_client/api/inbox_replier_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class InboxReplierControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def create_new_inbox_replier(self, create_inbox_replier_options, **kwargs):  # noqa: E501
        """Create an inbox replier  # noqa: E501

        Create a new inbox rule for reply toing, 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_replier(create_inbox_replier_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateInboxReplierOptions create_inbox_replier_options: (required)
        :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: InboxReplierDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_new_inbox_replier_with_http_info(create_inbox_replier_options, **kwargs)  # noqa: E501

    def create_new_inbox_replier_with_http_info(self, create_inbox_replier_options, **kwargs):  # noqa: E501
        """Create an inbox replier  # noqa: E501

        Create a new inbox rule for reply toing, 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_replier_with_http_info(create_inbox_replier_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateInboxReplierOptions create_inbox_replier_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(InboxReplierDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_inbox_replier_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_new_inbox_replier" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'create_inbox_replier_options' is set
        if self.api_client.client_side_validation and ('create_inbox_replier_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_inbox_replier_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_inbox_replier_options` when calling `create_new_inbox_replier`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_inbox_replier_options' in local_var_params:
            body_params = local_var_params['create_inbox_replier_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(
            '/repliers', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxReplierDto',  # 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_replier(self, id, **kwargs):  # noqa: E501
        """Delete an inbox replier  # noqa: E501

        Delete inbox replier  # 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_replier(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox replier (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_inbox_replier_with_http_info(id, **kwargs)  # noqa: E501

    def delete_inbox_replier_with_http_info(self, id, **kwargs):  # noqa: E501
        """Delete an inbox replier  # noqa: E501

        Delete inbox replier  # 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_replier_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox replier (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 = [
            '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_replier" % 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 `delete_inbox_replier`")  # 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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/repliers/{id}', '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 delete_inbox_repliers(self, **kwargs):  # noqa: E501
        """Delete inbox repliers  # noqa: E501

        Delete inbox repliers. 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_repliers(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Optional inbox id to attach replier to
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_inbox_repliers_with_http_info(**kwargs)  # noqa: E501

    def delete_inbox_repliers_with_http_info(self, **kwargs):  # noqa: E501
        """Delete inbox repliers  # noqa: E501

        Delete inbox repliers. 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_repliers_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 replier 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_repliers" % 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(
            '/repliers', '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_replier(self, id, **kwargs):  # noqa: E501
        """Get an inbox replier  # 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_replier(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox replier (required)
        :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: InboxReplierDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_replier_with_http_info(id, **kwargs)  # noqa: E501

    def get_inbox_replier_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get an inbox replier  # 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_replier_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox replier (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(InboxReplierDto, 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_replier" % 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_replier`")  # 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/repliers/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxReplierDto',  # 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_replier_events(self, id, **kwargs):  # noqa: E501
        """Get an inbox replier event list  # noqa: E501

        Get inbox ruleset events  # 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_replier_events(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox replier (required)
        :param int page: Optional page index in inbox replier event list pagination
        :param int size: Optional page size in inbox replier event list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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: PageInboxReplierEvents
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_replier_events_with_http_info(id, **kwargs)  # noqa: E501

    def get_inbox_replier_events_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get an inbox replier event list  # noqa: E501

        Get inbox ruleset events  # 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_replier_events_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox replier (required)
        :param int page: Optional page index in inbox replier event list pagination
        :param int size: Optional page size in inbox replier event 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(PageInboxReplierEvents, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            '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_inbox_replier_events" % 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_replier_events`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/repliers/{id}/events', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageInboxReplierEvents',  # 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_repliers(self, **kwargs):  # noqa: E501
        """List inbox repliers  # noqa: E501

        List all repliers 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_repliers(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Optional inbox id to get repliers from
        :param int page: Optional page index in inbox replier list pagination
        :param int size: Optional page size in inbox replier list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageInboxReplierDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_repliers_with_http_info(**kwargs)  # noqa: E501

    def get_inbox_repliers_with_http_info(self, **kwargs):  # noqa: E501
        """List inbox repliers  # noqa: E501

        List all repliers 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_repliers_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 repliers from
        :param int page: Optional page index in inbox replier list pagination
        :param int size: Optional page size in inbox replier list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PageInboxReplierDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort',
            '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 get_inbox_repliers" % 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 '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 '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(
            '/repliers', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageInboxReplierDto',  # 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_inbox_replier(self, id, update_inbox_replier_options, **kwargs):  # noqa: E501
        """Update an inbox replier  # noqa: E501

        Update 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.update_inbox_replier(id, update_inbox_replier_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox replier (required)
        :param UpdateInboxReplierOptions update_inbox_replier_options: (required)
        :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: InboxReplierDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_inbox_replier_with_http_info(id, update_inbox_replier_options, **kwargs)  # noqa: E501

    def update_inbox_replier_with_http_info(self, id, update_inbox_replier_options, **kwargs):  # noqa: E501
        """Update an inbox replier  # noqa: E501

        Update 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.update_inbox_replier_with_http_info(id, update_inbox_replier_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox replier (required)
        :param UpdateInboxReplierOptions update_inbox_replier_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(InboxReplierDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'id',
            'update_inbox_replier_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_inbox_replier" % 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_inbox_replier`")  # noqa: E501
        # verify the required parameter 'update_inbox_replier_options' is set
        if self.api_client.client_side_validation and ('update_inbox_replier_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['update_inbox_replier_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `update_inbox_replier_options` when calling `update_inbox_replier`")  # 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_inbox_replier_options' in local_var_params:
            body_params = local_var_params['update_inbox_replier_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(
            '/repliers/{id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxReplierDto',  # 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)

mailslurp_client/api/inbox_forwarder_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class InboxForwarderControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def create_new_inbox_forwarder(self, inbox_id, 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(inbox_id, create_inbox_forwarder_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Inbox id to attach forwarder to (required)
        :param CreateInboxForwarderOptions create_inbox_forwarder_options: (required)
        :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: InboxForwarderDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_new_inbox_forwarder_with_http_info(inbox_id, create_inbox_forwarder_options, **kwargs)  # noqa: E501

    def create_new_inbox_forwarder_with_http_info(self, inbox_id, 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(inbox_id, create_inbox_forwarder_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Inbox id to attach forwarder to (required)
        :param CreateInboxForwarderOptions create_inbox_forwarder_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(InboxForwarderDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'create_inbox_forwarder_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_new_inbox_forwarder" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `create_new_inbox_forwarder`")  # noqa: E501
        # 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(
            ['*/*'])  # 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 delete_inbox_forwarder(self, id, **kwargs):  # noqa: E501
        """Delete an inbox forwarder  # noqa: E501

        Delete inbox forwarder  # 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_forwarder(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox forwarder (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_inbox_forwarder_with_http_info(id, **kwargs)  # noqa: E501

    def delete_inbox_forwarder_with_http_info(self, id, **kwargs):  # noqa: E501
        """Delete an inbox forwarder  # noqa: E501

        Delete inbox forwarder  # 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_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: None
                 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 delete_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 `delete_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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/forwarders/{id}', '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 delete_inbox_forwarders(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(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 _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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_inbox_forwarders_with_http_info(**kwargs)  # noqa: E501

    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_all_inbox_forwarder_events(self, **kwargs):  # noqa: E501
        """Get all inbox forwarder events  # noqa: E501

        Get all inbox forwarder events  # 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_all_inbox_forwarder_events(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index in inbox forwarder event list pagination
        :param int size: Optional page size in inbox forwarder event list pagination
        :param str inbox_id: Optional inbox ID to filter for
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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: PageInboxForwarderEvents
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_all_inbox_forwarder_events_with_http_info(**kwargs)  # noqa: E501

    def get_all_inbox_forwarder_events_with_http_info(self, **kwargs):  # noqa: E501
        """Get all inbox forwarder events  # noqa: E501

        Get all inbox forwarder events  # 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_all_inbox_forwarder_events_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index in inbox forwarder event list pagination
        :param int size: Optional page size in inbox forwarder event list pagination
        :param str inbox_id: Optional inbox ID to filter for
        :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(PageInboxForwarderEvents, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'inbox_id',
            '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_all_inbox_forwarder_events" % 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 '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 '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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/forwarders/events', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageInboxForwarderEvents',  # 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_forwarder_event(self, event_id, **kwargs):  # noqa: E501
        """Get a forwarder event  # noqa: E501

        Get forwarder event  # 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_forwarder_event(event_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str event_id: ID of inbox forwarder event (required)
        :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: InboxForwarderEventDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_forwarder_event_with_http_info(event_id, **kwargs)  # noqa: E501

    def get_forwarder_event_with_http_info(self, event_id, **kwargs):  # noqa: E501
        """Get a forwarder event  # noqa: E501

        Get forwarder event  # 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_forwarder_event_with_http_info(event_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str event_id: ID of inbox forwarder event (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(InboxForwarderEventDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'event_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_forwarder_event" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'event_id' is set
        if self.api_client.client_side_validation and ('event_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['event_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `event_id` when calling `get_forwarder_event`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'event_id' in local_var_params:
            path_params['eventId'] = local_var_params['event_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/forwarders/events/{eventId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxForwarderEventDto',  # 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(self, id, **kwargs):  # noqa: E501
        """Get an inbox forwarder  # noqa: E501

        Get inbox forwarder  # 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(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox forwarder (required)
        :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: InboxForwarderDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_forwarder_with_http_info(id, **kwargs)  # noqa: E501

    def get_inbox_forwarder_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get an inbox forwarder  # noqa: E501

        Get inbox forwarder  # 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(
            ['*/*'])  # 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 get_inbox_forwarder_event(self, id, event_id, **kwargs):  # noqa: E501
        """Get an inbox forwarder event  # noqa: E501

        Get inbox forwarder event  # 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_event(id, event_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox forwarder (required)
        :param str event_id: ID of inbox forwarder event (required)
        :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: InboxForwarderEventDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_forwarder_event_with_http_info(id, event_id, **kwargs)  # noqa: E501

    def get_inbox_forwarder_event_with_http_info(self, id, event_id, **kwargs):  # noqa: E501
        """Get an inbox forwarder event  # noqa: E501

        Get inbox forwarder event  # 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_event_with_http_info(id, event_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox forwarder (required)
        :param str event_id: ID of inbox forwarder event (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(InboxForwarderEventDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'id',
            'event_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_event" % 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_event`")  # noqa: E501
        # verify the required parameter 'event_id' is set
        if self.api_client.client_side_validation and ('event_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['event_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `event_id` when calling `get_inbox_forwarder_event`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'event_id' in local_var_params:
            path_params['eventId'] = local_var_params['event_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/forwarders/{id}/events/{eventId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxForwarderEventDto',  # 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_events(self, id, **kwargs):  # noqa: E501
        """Get an inbox forwarder event list  # noqa: E501

        Get inbox forwarder events  # 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_events(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox forwarder (required)
        :param int page: Optional page index in inbox forwarder event list pagination
        :param int size: Optional page size in inbox forwarder event list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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: PageInboxForwarderEvents
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_forwarder_events_with_http_info(id, **kwargs)  # noqa: E501

    def get_inbox_forwarder_events_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get an inbox forwarder event list  # noqa: E501

        Get inbox forwarder events  # 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_events_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 int page: Optional page index in inbox forwarder event list pagination
        :param int size: Optional page size in inbox forwarder event 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(PageInboxForwarderEvents, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            '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_inbox_forwarder_events" % 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_events`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/forwarders/{id}/events', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageInboxForwarderEvents',  # 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(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(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 int size: Optional page size in inbox forwarder list pagination
        :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 _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: PageInboxForwarderDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_forwarders_with_http_info(**kwargs)  # noqa: E501

    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 int size: Optional page size in inbox forwarder list pagination
        :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 _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',
            'size',
            'sort',
            'search_filter',
            '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 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 '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

        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(
            '/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 test_inbox_forwarder(self, id, inbox_forwarder_test_options, **kwargs):  # noqa: E501
        """Test an inbox forwarder  # noqa: E501

        Test an inbox forwarder  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.test_inbox_forwarder(id, inbox_forwarder_test_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox forwarder (required)
        :param InboxForwarderTestOptions inbox_forwarder_test_options: (required)
        :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: InboxForwarderTestResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.test_inbox_forwarder_with_http_info(id, inbox_forwarder_test_options, **kwargs)  # noqa: E501

    def test_inbox_forwarder_with_http_info(self, id, inbox_forwarder_test_options, **kwargs):  # noqa: E501
        """Test an inbox forwarder  # noqa: E501

        Test an inbox forwarder  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.test_inbox_forwarder_with_http_info(id, inbox_forwarder_test_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox forwarder (required)
        :param InboxForwarderTestOptions inbox_forwarder_test_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(InboxForwarderTestResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'id',
            'inbox_forwarder_test_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 test_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 `test_inbox_forwarder`")  # noqa: E501
        # verify the required parameter 'inbox_forwarder_test_options' is set
        if self.api_client.client_side_validation and ('inbox_forwarder_test_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_forwarder_test_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_forwarder_test_options` when calling `test_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
        if 'inbox_forwarder_test_options' in local_var_params:
            body_params = local_var_params['inbox_forwarder_test_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(
            '/forwarders/{id}/test', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxForwarderTestResult',  # 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 test_inbox_forwarders_for_inbox(self, inbox_id, inbox_forwarder_test_options, **kwargs):  # noqa: E501
        """Test inbox forwarders for inbox  # noqa: E501

        Test inbox forwarders for 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.test_inbox_forwarders_for_inbox(inbox_id, inbox_forwarder_test_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox (required)
        :param InboxForwarderTestOptions inbox_forwarder_test_options: (required)
        :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: InboxForwarderTestResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.test_inbox_forwarders_for_inbox_with_http_info(inbox_id, inbox_forwarder_test_options, **kwargs)  # noqa: E501

    def test_inbox_forwarders_for_inbox_with_http_info(self, inbox_id, inbox_forwarder_test_options, **kwargs):  # noqa: E501
        """Test inbox forwarders for inbox  # noqa: E501

        Test inbox forwarders for 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.test_inbox_forwarders_for_inbox_with_http_info(inbox_id, inbox_forwarder_test_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox (required)
        :param InboxForwarderTestOptions inbox_forwarder_test_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(InboxForwarderTestResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'inbox_forwarder_test_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 test_inbox_forwarders_for_inbox" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `test_inbox_forwarders_for_inbox`")  # noqa: E501
        # verify the required parameter 'inbox_forwarder_test_options' is set
        if self.api_client.client_side_validation and ('inbox_forwarder_test_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_forwarder_test_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_forwarder_test_options` when calling `test_inbox_forwarders_for_inbox`")  # 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 'inbox_forwarder_test_options' in local_var_params:
            body_params = local_var_params['inbox_forwarder_test_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(
            '/forwarders', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxForwarderTestResult',  # 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 test_new_inbox_forwarder(self, test_new_inbox_forwarder_options, **kwargs):  # noqa: E501
        """Test new inbox forwarder  # noqa: E501

        Test new inbox forwarder  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.test_new_inbox_forwarder(test_new_inbox_forwarder_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param TestNewInboxForwarderOptions test_new_inbox_forwarder_options: (required)
        :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: InboxForwarderTestResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.test_new_inbox_forwarder_with_http_info(test_new_inbox_forwarder_options, **kwargs)  # noqa: E501

    def test_new_inbox_forwarder_with_http_info(self, test_new_inbox_forwarder_options, **kwargs):  # noqa: E501
        """Test new inbox forwarder  # noqa: E501

        Test new inbox forwarder  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.test_new_inbox_forwarder_with_http_info(test_new_inbox_forwarder_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param TestNewInboxForwarderOptions test_new_inbox_forwarder_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(InboxForwarderTestResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'test_new_inbox_forwarder_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 test_new_inbox_forwarder" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'test_new_inbox_forwarder_options' is set
        if self.api_client.client_side_validation and ('test_new_inbox_forwarder_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['test_new_inbox_forwarder_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `test_new_inbox_forwarder_options` when calling `test_new_inbox_forwarder`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'test_new_inbox_forwarder_options' in local_var_params:
            body_params = local_var_params['test_new_inbox_forwarder_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(
            '/forwarders', 'PATCH',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxForwarderTestResult',  # 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_inbox_forwarder(self, id, create_inbox_forwarder_options, **kwargs):  # noqa: E501
        """Update an inbox forwarder  # noqa: E501

        Update inbox forwarder  # 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_inbox_forwarder(id, create_inbox_forwarder_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox forwarder (required)
        :param CreateInboxForwarderOptions create_inbox_forwarder_options: (required)
        :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: InboxForwarderDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_inbox_forwarder_with_http_info(id, create_inbox_forwarder_options, **kwargs)  # noqa: E501

    def update_inbox_forwarder_with_http_info(self, id, create_inbox_forwarder_options, **kwargs):  # noqa: E501
        """Update an inbox forwarder  # noqa: E501

        Update inbox forwarder  # 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_inbox_forwarder_with_http_info(id, create_inbox_forwarder_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of inbox forwarder (required)
        :param CreateInboxForwarderOptions create_inbox_forwarder_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(InboxForwarderDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'id',
            'create_inbox_forwarder_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_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 `update_inbox_forwarder`")  # noqa: E501
        # 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 `update_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
        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(
            ['*/*'])  # 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/{id}', 'PUT',
            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)

mailslurp_client/api/inbox_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class InboxControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def cancel_scheduled_job(self, job_id, **kwargs):  # noqa: E501
        """Cancel a scheduled email job  # noqa: E501

        Get a scheduled email job and cancel it. Will fail if status of job is already cancelled, failed, or complete.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.cancel_scheduled_job(job_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str job_id: (required)
        :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: ScheduledJobDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.cancel_scheduled_job_with_http_info(job_id, **kwargs)  # noqa: E501

    def cancel_scheduled_job_with_http_info(self, job_id, **kwargs):  # noqa: E501
        """Cancel a scheduled email job  # noqa: E501

        Get a scheduled email job and cancel it. Will fail if status of job is already cancelled, failed, or complete.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.cancel_scheduled_job_with_http_info(job_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str job_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: tuple(ScheduledJobDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'job_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 cancel_scheduled_job" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'job_id' is set
        if self.api_client.client_side_validation and ('job_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['job_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `job_id` when calling `cancel_scheduled_job`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'job_id' in local_var_params:
            path_params['jobId'] = local_var_params['job_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/inboxes/scheduled-jobs/{jobId}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ScheduledJobDto',  # 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_inbox(self, **kwargs):  # noqa: E501
        """Create an inbox email address. An inbox has a real email address and can send and receive emails. Inboxes can be either `SMTP` or `HTTP` inboxes.  # noqa: E501

        Create a new inbox and with a randomized email address to send and receive from. Pass emailAddress parameter if you wish to use a specific email address. Creating an inbox is required before sending or receiving emails. If writing tests it is recommended that you create a new inbox during each test method so that it is unique and empty.   # 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_inbox(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_address: A custom email address to use with the inbox. Defaults to null. When null MailSlurp will assign a random email address to the inbox such as `123@mailslurp.com`. If you use the `useDomainPool` option when the email address is null it will generate an email address with a more varied domain ending such as `123@mailslurp.info` or `123@mailslurp.biz`. When a custom email address is provided the address is split into a domain and the domain is queried against your user. If you have created the domain in the MailSlurp dashboard and verified it you can use any email address that ends with the domain. Note domain types must match the inbox type - so `SMTP` inboxes will only work with `SMTP` type domains. Avoid `SMTP` inboxes if you need to send emails as they can only receive. Send an email to this address and the inbox will receive and store it for you. To retrieve the email use the Inbox and Email Controller endpoints with the inbox ID.
        :param list[str] tags: Tags that inbox has been tagged with. Tags can be added to inboxes to group different inboxes within an account. You can also search for inboxes by tag in the dashboard UI.
        :param str name: Optional name of the inbox. Displayed in the dashboard for easier search and used as the sender name when sending emails.
        :param str description: Optional description of the inbox for labelling purposes. Is shown in the dashboard and can be used with
        :param bool use_domain_pool: Use the MailSlurp domain name pool with this inbox when creating the email address. Defaults to null. If enabled the inbox will be an email address with a domain randomly chosen from a list of the MailSlurp domains. This is useful when the default `@mailslurp.com` email addresses used with inboxes are blocked or considered spam by a provider or receiving service. When domain pool is enabled an email address will be generated ending in `@mailslurp.{world,info,xyz,...}` . This means a TLD is randomly selecting from a list of `.biz`, `.info`, `.xyz` etc to add variance to the generated email addresses. When null or false MailSlurp uses the default behavior of `@mailslurp.com` or custom email address provided by the emailAddress field. Note this feature is only available for `HTTP` inbox types.
        :param bool favourite: Is the inbox a favorite. Marking an inbox as a favorite is typically done in the dashboard for quick access or filtering
        :param datetime expires_at: Optional inbox expiration date. If null then this inbox is permanent and the emails in it won't be deleted. If an expiration date is provided or is required by your plan the inbox will be closed when the expiration time is reached. Expired inboxes still contain their emails but can no longer send or receive emails. An ExpiredInboxRecord is created when an inbox and the email address and inbox ID are recorded. The expiresAt property is a timestamp string in ISO DateTime Format yyyy-MM-dd'T'HH:mm:ss.SSSXXX.
        :param int expires_in: Number of milliseconds that inbox should exist for
        :param bool allow_team_access: DEPRECATED (team access is always true). Grant team access to this inbox and the emails that belong to it for team members of your organization.
        :param str inbox_type: HTTP (default) or SMTP inbox type. HTTP inboxes are default and best solution for most cases. SMTP inboxes are more reliable for public inbound email consumption (but do not support sending emails). When using custom domains the domain type must match the inbox type. HTTP inboxes are processed by AWS SES while SMTP inboxes use a custom mail server running at `mxslurp.click`.
        :param bool virtual_inbox: Virtual inbox prevents any outbound emails from being sent. It creates sent email records but will never send real emails to recipients. Great for testing and faking email sending.
        :param bool use_short_address: Use a shorter email address under 31 characters
        :param str domain_id: ID of custom domain to use for email address.
        :param str domain_name: FQDN domain name for the domain you have verified. Will be appended with a randomly assigned recipient name. Use the `emailAddress` option instead to specify the full custom inbox.
        :param str prefix: Prefix to add before the email address for easier labelling or identification.
        :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: InboxDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_inbox_with_http_info(**kwargs)  # noqa: E501

    def create_inbox_with_http_info(self, **kwargs):  # noqa: E501
        """Create an inbox email address. An inbox has a real email address and can send and receive emails. Inboxes can be either `SMTP` or `HTTP` inboxes.  # noqa: E501

        Create a new inbox and with a randomized email address to send and receive from. Pass emailAddress parameter if you wish to use a specific email address. Creating an inbox is required before sending or receiving emails. If writing tests it is recommended that you create a new inbox during each test method so that it is unique and empty.   # 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_inbox_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_address: A custom email address to use with the inbox. Defaults to null. When null MailSlurp will assign a random email address to the inbox such as `123@mailslurp.com`. If you use the `useDomainPool` option when the email address is null it will generate an email address with a more varied domain ending such as `123@mailslurp.info` or `123@mailslurp.biz`. When a custom email address is provided the address is split into a domain and the domain is queried against your user. If you have created the domain in the MailSlurp dashboard and verified it you can use any email address that ends with the domain. Note domain types must match the inbox type - so `SMTP` inboxes will only work with `SMTP` type domains. Avoid `SMTP` inboxes if you need to send emails as they can only receive. Send an email to this address and the inbox will receive and store it for you. To retrieve the email use the Inbox and Email Controller endpoints with the inbox ID.
        :param list[str] tags: Tags that inbox has been tagged with. Tags can be added to inboxes to group different inboxes within an account. You can also search for inboxes by tag in the dashboard UI.
        :param str name: Optional name of the inbox. Displayed in the dashboard for easier search and used as the sender name when sending emails.
        :param str description: Optional description of the inbox for labelling purposes. Is shown in the dashboard and can be used with
        :param bool use_domain_pool: Use the MailSlurp domain name pool with this inbox when creating the email address. Defaults to null. If enabled the inbox will be an email address with a domain randomly chosen from a list of the MailSlurp domains. This is useful when the default `@mailslurp.com` email addresses used with inboxes are blocked or considered spam by a provider or receiving service. When domain pool is enabled an email address will be generated ending in `@mailslurp.{world,info,xyz,...}` . This means a TLD is randomly selecting from a list of `.biz`, `.info`, `.xyz` etc to add variance to the generated email addresses. When null or false MailSlurp uses the default behavior of `@mailslurp.com` or custom email address provided by the emailAddress field. Note this feature is only available for `HTTP` inbox types.
        :param bool favourite: Is the inbox a favorite. Marking an inbox as a favorite is typically done in the dashboard for quick access or filtering
        :param datetime expires_at: Optional inbox expiration date. If null then this inbox is permanent and the emails in it won't be deleted. If an expiration date is provided or is required by your plan the inbox will be closed when the expiration time is reached. Expired inboxes still contain their emails but can no longer send or receive emails. An ExpiredInboxRecord is created when an inbox and the email address and inbox ID are recorded. The expiresAt property is a timestamp string in ISO DateTime Format yyyy-MM-dd'T'HH:mm:ss.SSSXXX.
        :param int expires_in: Number of milliseconds that inbox should exist for
        :param bool allow_team_access: DEPRECATED (team access is always true). Grant team access to this inbox and the emails that belong to it for team members of your organization.
        :param str inbox_type: HTTP (default) or SMTP inbox type. HTTP inboxes are default and best solution for most cases. SMTP inboxes are more reliable for public inbound email consumption (but do not support sending emails). When using custom domains the domain type must match the inbox type. HTTP inboxes are processed by AWS SES while SMTP inboxes use a custom mail server running at `mxslurp.click`.
        :param bool virtual_inbox: Virtual inbox prevents any outbound emails from being sent. It creates sent email records but will never send real emails to recipients. Great for testing and faking email sending.
        :param bool use_short_address: Use a shorter email address under 31 characters
        :param str domain_id: ID of custom domain to use for email address.
        :param str domain_name: FQDN domain name for the domain you have verified. Will be appended with a randomly assigned recipient name. Use the `emailAddress` option instead to specify the full custom inbox.
        :param str prefix: Prefix to add before the email address for easier labelling or identification.
        :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(InboxDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_address',
            'tags',
            'name',
            'description',
            'use_domain_pool',
            'favourite',
            'expires_at',
            'expires_in',
            'allow_team_access',
            'inbox_type',
            'virtual_inbox',
            'use_short_address',
            'domain_id',
            'domain_name',
            'prefix'
        ]
        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_inbox" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'email_address' in local_var_params and local_var_params['email_address'] is not None:  # noqa: E501
            query_params.append(('emailAddress', local_var_params['email_address']))  # noqa: E501
        if 'tags' in local_var_params and local_var_params['tags'] is not None:  # noqa: E501
            query_params.append(('tags', local_var_params['tags']))  # noqa: E501
            collection_formats['tags'] = 'multi'  # noqa: E501
        if 'name' in local_var_params and local_var_params['name'] is not None:  # noqa: E501
            query_params.append(('name', local_var_params['name']))  # noqa: E501
        if 'description' in local_var_params and local_var_params['description'] is not None:  # noqa: E501
            query_params.append(('description', local_var_params['description']))  # 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
        if 'favourite' in local_var_params and local_var_params['favourite'] is not None:  # noqa: E501
            query_params.append(('favourite', local_var_params['favourite']))  # 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 '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 'inbox_type' in local_var_params and local_var_params['inbox_type'] is not None:  # noqa: E501
            query_params.append(('inboxType', local_var_params['inbox_type']))  # noqa: E501
        if 'virtual_inbox' in local_var_params and local_var_params['virtual_inbox'] is not None:  # noqa: E501
            query_params.append(('virtualInbox', local_var_params['virtual_inbox']))  # noqa: E501
        if 'use_short_address' in local_var_params and local_var_params['use_short_address'] is not None:  # noqa: E501
            query_params.append(('useShortAddress', local_var_params['use_short_address']))  # noqa: E501
        if 'domain_id' in local_var_params and local_var_params['domain_id'] is not None:  # noqa: E501
            query_params.append(('domainId', local_var_params['domain_id']))  # noqa: E501
        if 'domain_name' in local_var_params and local_var_params['domain_name'] is not None:  # noqa: E501
            query_params.append(('domainName', local_var_params['domain_name']))  # noqa: E501
        if 'prefix' in local_var_params and local_var_params['prefix'] is not None:  # noqa: E501
            query_params.append(('prefix', local_var_params['prefix']))  # 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(
            '/inboxes', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxDto',  # 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_inbox_ruleset(self, inbox_id, create_inbox_ruleset_options, **kwargs):  # noqa: E501
        """Create an inbox ruleset  # 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_inbox_ruleset(inbox_id, create_inbox_ruleset_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: inboxId (required)
        :param CreateInboxRulesetOptions create_inbox_ruleset_options: (required)
        :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: InboxRulesetDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_inbox_ruleset_with_http_info(inbox_id, create_inbox_ruleset_options, **kwargs)  # noqa: E501

    def create_inbox_ruleset_with_http_info(self, inbox_id, create_inbox_ruleset_options, **kwargs):  # noqa: E501
        """Create an inbox ruleset  # 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_inbox_ruleset_with_http_info(inbox_id, create_inbox_ruleset_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: inboxId (required)
        :param CreateInboxRulesetOptions create_inbox_ruleset_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(InboxRulesetDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'create_inbox_ruleset_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_inbox_ruleset" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `create_inbox_ruleset`")  # noqa: E501
        # verify the required parameter 'create_inbox_ruleset_options' is set
        if self.api_client.client_side_validation and ('create_inbox_ruleset_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_inbox_ruleset_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_inbox_ruleset_options` when calling `create_inbox_ruleset`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_inbox_ruleset_options' in local_var_params:
            body_params = local_var_params['create_inbox_ruleset_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(
            '/inboxes/{inboxId}/rulesets', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxRulesetDto',  # 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_inbox_with_defaults(self, **kwargs):  # noqa: E501
        """Create an inbox with default options. Uses MailSlurp domain pool address and is private.  # 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_inbox_with_defaults(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: InboxDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_inbox_with_defaults_with_http_info(**kwargs)  # noqa: E501

    def create_inbox_with_defaults_with_http_info(self, **kwargs):  # noqa: E501
        """Create an inbox with default options. Uses MailSlurp domain pool address and is private.  # 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_inbox_with_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(InboxDto, 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 create_inbox_with_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/inboxes/withDefaults', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxDto',  # 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_inbox_with_options(self, create_inbox_dto, **kwargs):  # noqa: E501
        """Create an inbox with options. Extended options for inbox creation.  # noqa: E501

        Additional endpoint that allows inbox creation with request body options. Can be more flexible that other methods for some clients.  # 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_inbox_with_options(create_inbox_dto, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateInboxDto create_inbox_dto: (required)
        :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: InboxDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_inbox_with_options_with_http_info(create_inbox_dto, **kwargs)  # noqa: E501

    def create_inbox_with_options_with_http_info(self, create_inbox_dto, **kwargs):  # noqa: E501
        """Create an inbox with options. Extended options for inbox creation.  # noqa: E501

        Additional endpoint that allows inbox creation with request body options. Can be more flexible that other methods for some clients.  # 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_inbox_with_options_with_http_info(create_inbox_dto, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateInboxDto create_inbox_dto: (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(InboxDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_inbox_dto'
        ]
        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_inbox_with_options" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'create_inbox_dto' is set
        if self.api_client.client_side_validation and ('create_inbox_dto' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_inbox_dto'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_inbox_dto` when calling `create_inbox_with_options`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_inbox_dto' in local_var_params:
            body_params = local_var_params['create_inbox_dto']
        # 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(
            '/inboxes/withOptions', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxDto',  # 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_all_inbox_emails(self, inbox_id, **kwargs):  # noqa: E501
        """Delete all emails in a given inboxes.  # noqa: E501

        Deletes all emails in an inbox. Be careful as emails cannot be recovered  # 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_all_inbox_emails(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_all_inbox_emails_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def delete_all_inbox_emails_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """Delete all emails in a given inboxes.  # noqa: E501

        Deletes all emails in an inbox. Be careful as emails cannot be recovered  # 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_all_inbox_emails_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_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 = [
            '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_all_inbox_emails" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `delete_all_inbox_emails`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_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(
            '/inboxes/{inboxId}/deleteAllInboxEmails', '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 delete_all_inboxes(self, **kwargs):  # noqa: E501
        """Delete all inboxes  # noqa: E501

        Permanently delete all inboxes and associated email addresses. This will also delete all emails within the inboxes. Be careful as inboxes cannot be recovered once deleted. Note: deleting inboxes will not impact your usage limits. Monthly inbox creation limits are based on how many inboxes were created in the last 30 days, not how many inboxes you currently have.  # 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_all_inboxes(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_all_inboxes_with_http_info(**kwargs)  # noqa: E501

    def delete_all_inboxes_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all inboxes  # noqa: E501

        Permanently delete all inboxes and associated email addresses. This will also delete all emails within the inboxes. Be careful as inboxes cannot be recovered once deleted. Note: deleting inboxes will not impact your usage limits. Monthly inbox creation limits are based on how many inboxes were created in the last 30 days, not how many inboxes you currently have.  # 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_all_inboxes_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: None
                 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 delete_all_inboxes" % 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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/inboxes', '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 delete_all_inboxes_by_description(self, description, **kwargs):  # noqa: E501
        """Delete inboxes by description  # noqa: E501

        Permanently delete all inboxes by description  # 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_all_inboxes_by_description(description, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str description: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_all_inboxes_by_description_with_http_info(description, **kwargs)  # noqa: E501

    def delete_all_inboxes_by_description_with_http_info(self, description, **kwargs):  # noqa: E501
        """Delete inboxes by description  # noqa: E501

        Permanently delete all inboxes by description  # 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_all_inboxes_by_description_with_http_info(description, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str description: (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 = [
            'description'
        ]
        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_all_inboxes_by_description" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'description' is set
        if self.api_client.client_side_validation and ('description' not in local_var_params or  # noqa: E501
                                                        local_var_params['description'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `description` when calling `delete_all_inboxes_by_description`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'description' in local_var_params and local_var_params['description'] is not None:  # noqa: E501
            query_params.append(('description', local_var_params['description']))  # 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(
            '/inboxes/by-description', '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 delete_all_inboxes_by_name(self, name, **kwargs):  # noqa: E501
        """Delete inboxes by name  # noqa: E501

        Permanently delete all inboxes by name  # 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_all_inboxes_by_name(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str name: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_all_inboxes_by_name_with_http_info(name, **kwargs)  # noqa: E501

    def delete_all_inboxes_by_name_with_http_info(self, name, **kwargs):  # noqa: E501
        """Delete inboxes by name  # noqa: E501

        Permanently delete all inboxes by name  # 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_all_inboxes_by_name_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str name: (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 = [
            'name'
        ]
        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_all_inboxes_by_name" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'name' is set
        if self.api_client.client_side_validation and ('name' not in local_var_params or  # noqa: E501
                                                        local_var_params['name'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `name` when calling `delete_all_inboxes_by_name`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'name' in local_var_params and local_var_params['name'] is not None:  # noqa: E501
            query_params.append(('name', local_var_params['name']))  # 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(
            '/inboxes/by-name', '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 delete_all_inboxes_by_tag(self, tag, **kwargs):  # noqa: E501
        """Delete inboxes by tag  # noqa: E501

        Permanently delete all inboxes by tag  # 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_all_inboxes_by_tag(tag, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str tag: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_all_inboxes_by_tag_with_http_info(tag, **kwargs)  # noqa: E501

    def delete_all_inboxes_by_tag_with_http_info(self, tag, **kwargs):  # noqa: E501
        """Delete inboxes by tag  # noqa: E501

        Permanently delete all inboxes by tag  # 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_all_inboxes_by_tag_with_http_info(tag, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str tag: (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 = [
            'tag'
        ]
        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_all_inboxes_by_tag" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'tag' is set
        if self.api_client.client_side_validation and ('tag' not in local_var_params or  # noqa: E501
                                                        local_var_params['tag'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `tag` when calling `delete_all_inboxes_by_tag`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'tag' in local_var_params and local_var_params['tag'] is not None:  # noqa: E501
            query_params.append(('tag', local_var_params['tag']))  # 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(
            '/inboxes/by-tag', '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 delete_inbox(self, inbox_id, **kwargs):  # noqa: E501
        """Delete inbox  # noqa: E501

        Permanently delete an inbox and associated email address as well as all emails within the given inbox. This action cannot be undone. Note: deleting an inbox will not affect your account usage. Monthly inbox usage is based on how many inboxes you create within 30 days, not how many exist at time of request.  # 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(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_inbox_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def delete_inbox_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """Delete inbox  # noqa: E501

        Permanently delete an inbox and associated email address as well as all emails within the given inbox. This action cannot be undone. Note: deleting an inbox will not affect your account usage. Monthly inbox usage is based on how many inboxes you create within 30 days, not how many exist at time of request.  # 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_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_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 = [
            '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" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `delete_inbox`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_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(
            '/inboxes/{inboxId}', '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 does_inbox_exist(self, email_address, **kwargs):  # noqa: E501
        """Does inbox exist  # noqa: E501

        Check if inboxes exist by email address. Useful if you are sending emails to mailslurp 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.does_inbox_exist(email_address, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_address: Email address (required)
        :param bool allow_catch_all:
        :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: InboxExistsDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.does_inbox_exist_with_http_info(email_address, **kwargs)  # noqa: E501

    def does_inbox_exist_with_http_info(self, email_address, **kwargs):  # noqa: E501
        """Does inbox exist  # noqa: E501

        Check if inboxes exist by email address. Useful if you are sending emails to mailslurp 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.does_inbox_exist_with_http_info(email_address, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_address: Email address (required)
        :param bool allow_catch_all:
        :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(InboxExistsDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_address',
            'allow_catch_all'
        ]
        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 does_inbox_exist" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_address' is set
        if self.api_client.client_side_validation and ('email_address' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_address'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_address` when calling `does_inbox_exist`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'email_address' in local_var_params and local_var_params['email_address'] is not None:  # noqa: E501
            query_params.append(('emailAddress', local_var_params['email_address']))  # noqa: E501
        if 'allow_catch_all' in local_var_params and local_var_params['allow_catch_all'] is not None:  # noqa: E501
            query_params.append(('allowCatchAll', local_var_params['allow_catch_all']))  # 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(
            '/inboxes/exists', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxExistsDto',  # 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 flush_expired(self, **kwargs):  # noqa: E501
        """Remove expired inboxes  # noqa: E501

        Remove any expired inboxes for your account (instead of waiting for scheduled removal on 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.flush_expired(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param datetime before: Optional expired at before flag to flush expired inboxes that have expired before the given time
        :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: FlushExpiredInboxesResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.flush_expired_with_http_info(**kwargs)  # noqa: E501

    def flush_expired_with_http_info(self, **kwargs):  # noqa: E501
        """Remove expired inboxes  # noqa: E501

        Remove any expired inboxes for your account (instead of waiting for scheduled removal on 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.flush_expired_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param datetime before: Optional expired at before flag to flush expired inboxes that have expired before the given 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(FlushExpiredInboxesResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            '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 flush_expired" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        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(
            '/inboxes/expired', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FlushExpiredInboxesResult',  # 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_all_inboxes(self, **kwargs):  # noqa: E501
        """List All Inboxes Paginated  # noqa: E501

        List inboxes in paginated form. The results are available on the `content` property of the returned object. This method allows for page index (zero based), page size (how many results to return), and a sort direction (based on createdAt time). You Can also filter by whether an inbox is favorited or use email address pattern. This method is the recommended way to query inboxes. The alternative `getInboxes` method returns a full list of inboxes but is limited to 100 results.  # 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_all_inboxes(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 in list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param bool favourite: Optionally filter results for favourites only
        :param str search: Optionally filter by search words partial matching ID, tags, name, and email address
        :param str tag: Optionally filter by tags. Will return inboxes that include given tags
        :param bool team_access: DEPRECATED. Optionally filter by team access.
        :param datetime since: Optional filter by created after given date time
        :param datetime before: Optional filter by created before given date time
        :param str inbox_type: Optional filter by inbox type
        :param str inbox_function: Optional filter by inbox function
        :param str domain_id: Optional domain ID filter
        :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: PageInboxProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_all_inboxes_with_http_info(**kwargs)  # noqa: E501

    def get_all_inboxes_with_http_info(self, **kwargs):  # noqa: E501
        """List All Inboxes Paginated  # noqa: E501

        List inboxes in paginated form. The results are available on the `content` property of the returned object. This method allows for page index (zero based), page size (how many results to return), and a sort direction (based on createdAt time). You Can also filter by whether an inbox is favorited or use email address pattern. This method is the recommended way to query inboxes. The alternative `getInboxes` method returns a full list of inboxes but is limited to 100 results.  # 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_all_inboxes_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 in list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param bool favourite: Optionally filter results for favourites only
        :param str search: Optionally filter by search words partial matching ID, tags, name, and email address
        :param str tag: Optionally filter by tags. Will return inboxes that include given tags
        :param bool team_access: DEPRECATED. Optionally filter by team access.
        :param datetime since: Optional filter by created after given date time
        :param datetime before: Optional filter by created before given date time
        :param str inbox_type: Optional filter by inbox type
        :param str inbox_function: Optional filter by inbox function
        :param str domain_id: Optional domain ID filter
        :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(PageInboxProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            'favourite',
            'search',
            'tag',
            'team_access',
            'since',
            'before',
            'inbox_type',
            'inbox_function',
            'domain_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_all_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
        if 'favourite' in local_var_params and local_var_params['favourite'] is not None:  # noqa: E501
            query_params.append(('favourite', local_var_params['favourite']))  # noqa: E501
        if 'search' in local_var_params and local_var_params['search'] is not None:  # noqa: E501
            query_params.append(('search', local_var_params['search']))  # noqa: E501
        if 'tag' in local_var_params and local_var_params['tag'] is not None:  # noqa: E501
            query_params.append(('tag', local_var_params['tag']))  # noqa: E501
        if 'team_access' in local_var_params and local_var_params['team_access'] is not None:  # noqa: E501
            query_params.append(('teamAccess', local_var_params['team_access']))  # 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 'inbox_type' in local_var_params and local_var_params['inbox_type'] is not None:  # noqa: E501
            query_params.append(('inboxType', local_var_params['inbox_type']))  # noqa: E501
        if 'inbox_function' in local_var_params and local_var_params['inbox_function'] is not None:  # noqa: E501
            query_params.append(('inboxFunction', local_var_params['inbox_function']))  # noqa: E501
        if 'domain_id' in local_var_params and local_var_params['domain_id'] is not None:  # noqa: E501
            query_params.append(('domainId', local_var_params['domain_id']))  # 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(
            '/inboxes/paginated', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageInboxProjection',  # 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_all_inboxes_offset_paginated(self, **kwargs):  # noqa: E501
        """List All Inboxes Offset Paginated  # noqa: E501

        List inboxes in paginated form. The results are available on the `content` property of the returned object. This method allows for page index (zero based), page size (how many results to return), and a sort direction (based on createdAt time). You Can also filter by whether an inbox is favorited or use email address pattern. This method is the recommended way to query inboxes. The alternative `getInboxes` method returns a full list of inboxes but is limited to 100 results.  # 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_all_inboxes_offset_paginated(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 in list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param bool favourite: Optionally filter results for favourites only
        :param str search: Optionally filter by search words partial matching ID, tags, name, and email address
        :param str tag: Optionally filter by tags. Will return inboxes that include given tags
        :param bool team_access: DEPRECATED. Optionally filter by team access.
        :param datetime since: Optional filter by created after given date time
        :param datetime before: Optional filter by created before given date time
        :param str inbox_type: Optional filter by inbox type
        :param str inbox_function: Optional filter by inbox function
        :param str domain_id: Optional domain ID filter
        :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: PageInboxProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_all_inboxes_offset_paginated_with_http_info(**kwargs)  # noqa: E501

    def get_all_inboxes_offset_paginated_with_http_info(self, **kwargs):  # noqa: E501
        """List All Inboxes Offset Paginated  # noqa: E501

        List inboxes in paginated form. The results are available on the `content` property of the returned object. This method allows for page index (zero based), page size (how many results to return), and a sort direction (based on createdAt time). You Can also filter by whether an inbox is favorited or use email address pattern. This method is the recommended way to query inboxes. The alternative `getInboxes` method returns a full list of inboxes but is limited to 100 results.  # 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_all_inboxes_offset_paginated_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 in list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param bool favourite: Optionally filter results for favourites only
        :param str search: Optionally filter by search words partial matching ID, tags, name, and email address
        :param str tag: Optionally filter by tags. Will return inboxes that include given tags
        :param bool team_access: DEPRECATED. Optionally filter by team access.
        :param datetime since: Optional filter by created after given date time
        :param datetime before: Optional filter by created before given date time
        :param str inbox_type: Optional filter by inbox type
        :param str inbox_function: Optional filter by inbox function
        :param str domain_id: Optional domain ID filter
        :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(PageInboxProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            'favourite',
            'search',
            'tag',
            'team_access',
            'since',
            'before',
            'inbox_type',
            'inbox_function',
            'domain_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_all_inboxes_offset_paginated" % 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
        if 'favourite' in local_var_params and local_var_params['favourite'] is not None:  # noqa: E501
            query_params.append(('favourite', local_var_params['favourite']))  # noqa: E501
        if 'search' in local_var_params and local_var_params['search'] is not None:  # noqa: E501
            query_params.append(('search', local_var_params['search']))  # noqa: E501
        if 'tag' in local_var_params and local_var_params['tag'] is not None:  # noqa: E501
            query_params.append(('tag', local_var_params['tag']))  # noqa: E501
        if 'team_access' in local_var_params and local_var_params['team_access'] is not None:  # noqa: E501
            query_params.append(('teamAccess', local_var_params['team_access']))  # 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 'inbox_type' in local_var_params and local_var_params['inbox_type'] is not None:  # noqa: E501
            query_params.append(('inboxType', local_var_params['inbox_type']))  # noqa: E501
        if 'inbox_function' in local_var_params and local_var_params['inbox_function'] is not None:  # noqa: E501
            query_params.append(('inboxFunction', local_var_params['inbox_function']))  # noqa: E501
        if 'domain_id' in local_var_params and local_var_params['domain_id'] is not None:  # noqa: E501
            query_params.append(('domainId', local_var_params['domain_id']))  # 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(
            '/inboxes/offset-paginated', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageInboxProjection',  # 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_all_scheduled_jobs(self, **kwargs):  # noqa: E501
        """Get all scheduled email sending jobs for account  # noqa: E501

        Schedule sending of emails using scheduled jobs. These can be inbox or account level.  # 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_all_scheduled_jobs(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index in scheduled job list pagination
        :param int size: Optional page size in scheduled job list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageScheduledJobs
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_all_scheduled_jobs_with_http_info(**kwargs)  # noqa: E501

    def get_all_scheduled_jobs_with_http_info(self, **kwargs):  # noqa: E501
        """Get all scheduled email sending jobs for account  # noqa: E501

        Schedule sending of emails using scheduled jobs. These can be inbox or account level.  # 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_all_scheduled_jobs_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index in scheduled job list pagination
        :param int size: Optional page size in scheduled job list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PageScheduledJobs, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            '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 get_all_scheduled_jobs" % 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
        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(
            '/inboxes/scheduled-jobs', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageScheduledJobs',  # 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_delivery_statuses_by_inbox_id(self, inbox_id, **kwargs):  # noqa: E501
        """get_delivery_statuses_by_inbox_id  # noqa: E501

        Get all email delivery statuses for 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_delivery_statuses_by_inbox_id(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param int page: Optional page index in delivery status list pagination
        :param int size: Optional page size in delivery status list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageDeliveryStatus
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_delivery_statuses_by_inbox_id_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def get_delivery_statuses_by_inbox_id_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """get_delivery_statuses_by_inbox_id  # noqa: E501

        Get all email delivery statuses for 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_delivery_statuses_by_inbox_id_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param int page: Optional page index in delivery status list pagination
        :param int size: Optional page size in delivery status list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PageDeliveryStatus, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort',
            '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 get_delivery_statuses_by_inbox_id" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `get_delivery_statuses_by_inbox_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_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
        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(
            '/inboxes/{inboxId}/delivery-status', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageDeliveryStatus',  # 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_emails(self, inbox_id, **kwargs):  # noqa: E501
        """Get emails in an Inbox. This method is not idempotent as it allows retries and waits if you want certain conditions to be met before returning. For simple listing and sorting of known emails use the email controller instead.  # noqa: E501

        List emails that an inbox has received. Only emails that are sent to the inbox's email address will appear in the inbox. It may take several seconds for any email you send to an inbox's email address to appear in the inbox. To make this endpoint wait for a minimum number of emails use the `minCount` parameter. The server will retry the inbox database until the `minCount` is satisfied or the `retryTimeout` is reached  # 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_emails(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Id of inbox that emails belongs to (required)
        :param int size: Alias for limit. Assessed first before assessing any passed limit.
        :param int limit: Limit the result set, ordered by received date time sort direction. Maximum 100. For more listing options see the email controller
        :param str sort: Sort the results by received date and direction ASC or DESC
        :param int retry_timeout: Maximum milliseconds to spend retrying inbox database until minCount emails are returned
        :param int delay_timeout:
        :param int min_count: Minimum acceptable email count. Will cause request to hang (and retry) until minCount is satisfied or retryTimeout is reached.
        :param bool unread_only:
        :param datetime before: Exclude emails received after this ISO 8601 date time
        :param datetime since: Exclude emails received before this ISO 8601 date time
        :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: list[EmailPreview]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_emails_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def get_emails_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """Get emails in an Inbox. This method is not idempotent as it allows retries and waits if you want certain conditions to be met before returning. For simple listing and sorting of known emails use the email controller instead.  # noqa: E501

        List emails that an inbox has received. Only emails that are sent to the inbox's email address will appear in the inbox. It may take several seconds for any email you send to an inbox's email address to appear in the inbox. To make this endpoint wait for a minimum number of emails use the `minCount` parameter. The server will retry the inbox database until the `minCount` is satisfied or the `retryTimeout` is reached  # 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_emails_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Id of inbox that emails belongs to (required)
        :param int size: Alias for limit. Assessed first before assessing any passed limit.
        :param int limit: Limit the result set, ordered by received date time sort direction. Maximum 100. For more listing options see the email controller
        :param str sort: Sort the results by received date and direction ASC or DESC
        :param int retry_timeout: Maximum milliseconds to spend retrying inbox database until minCount emails are returned
        :param int delay_timeout:
        :param int min_count: Minimum acceptable email count. Will cause request to hang (and retry) until minCount is satisfied or retryTimeout is reached.
        :param bool unread_only:
        :param datetime before: Exclude emails received after this ISO 8601 date time
        :param datetime since: Exclude emails received before this ISO 8601 date 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[EmailPreview], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'size',
            'limit',
            'sort',
            'retry_timeout',
            'delay_timeout',
            'min_count',
            'unread_only',
            'before',
            'since'
        ]
        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_emails" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `get_emails`")  # 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_emails`, must be a value less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params['limit'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `limit` when calling `get_emails`, must be a value less than or equal to `100`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []
        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 'limit' in local_var_params and local_var_params['limit'] is not None:  # noqa: E501
            query_params.append(('limit', local_var_params['limit']))  # 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 'retry_timeout' in local_var_params and local_var_params['retry_timeout'] is not None:  # noqa: E501
            query_params.append(('retryTimeout', local_var_params['retry_timeout']))  # noqa: E501
        if 'delay_timeout' in local_var_params and local_var_params['delay_timeout'] is not None:  # noqa: E501
            query_params.append(('delayTimeout', local_var_params['delay_timeout']))  # noqa: E501
        if 'min_count' in local_var_params and local_var_params['min_count'] is not None:  # noqa: E501
            query_params.append(('minCount', local_var_params['min_count']))  # 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
        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 '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

        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(
            '/inboxes/{inboxId}/emails', 'GET',
            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_imap_access(self, **kwargs):  # noqa: E501
        """get_imap_access  # noqa: E501

        Get IMAP access usernames and passwords  # 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_imap_access(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Inbox ID
        :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: ImapAccessDetails
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_imap_access_with_http_info(**kwargs)  # noqa: E501

    def get_imap_access_with_http_info(self, **kwargs):  # noqa: E501
        """get_imap_access  # noqa: E501

        Get IMAP access usernames and passwords  # 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_imap_access_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Inbox ID
        :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(ImapAccessDetails, status_code(int), headers(HTTPHeaderDict))
                 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 get_imap_access" % 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
        # 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(
            '/inboxes/imap-access', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ImapAccessDetails',  # 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_imap_smtp_access(self, **kwargs):  # noqa: E501
        """get_imap_smtp_access  # noqa: E501

        Get IMAP and SMTP access usernames and passwords  # 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_imap_smtp_access(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Inbox ID
        :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: ImapSmtpAccessDetails
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_imap_smtp_access_with_http_info(**kwargs)  # noqa: E501

    def get_imap_smtp_access_with_http_info(self, **kwargs):  # noqa: E501
        """get_imap_smtp_access  # noqa: E501

        Get IMAP and SMTP access usernames and passwords  # 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_imap_smtp_access_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Inbox ID
        :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(ImapSmtpAccessDetails, status_code(int), headers(HTTPHeaderDict))
                 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 get_imap_smtp_access" % 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
        # 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(
            '/inboxes/imap-smtp-access', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ImapSmtpAccessDetails',  # 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_imap_smtp_access_env(self, **kwargs):  # noqa: E501
        """get_imap_smtp_access_env  # noqa: E501

        Get IMAP and SMTP access details in .env format  # 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_imap_smtp_access_env(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Inbox ID
        :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: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_imap_smtp_access_env_with_http_info(**kwargs)  # noqa: E501

    def get_imap_smtp_access_env_with_http_info(self, **kwargs):  # noqa: E501
        """get_imap_smtp_access_env  # noqa: E501

        Get IMAP and SMTP access details in .env format  # 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_imap_smtp_access_env_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Inbox ID
        :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 = [
            '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 get_imap_smtp_access_env" % 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
        # 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(
            '/inboxes/imap-smtp-access/env', 'GET',
            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_imap_smtp_access_servers(self, **kwargs):  # noqa: E501
        """get_imap_smtp_access_servers  # noqa: E501

        Get IMAP and SMTP server hosts  # 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_imap_smtp_access_servers(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: ImapSmtpAccessServers
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_imap_smtp_access_servers_with_http_info(**kwargs)  # noqa: E501

    def get_imap_smtp_access_servers_with_http_info(self, **kwargs):  # noqa: E501
        """get_imap_smtp_access_servers  # noqa: E501

        Get IMAP and SMTP server hosts  # 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_imap_smtp_access_servers_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(ImapSmtpAccessServers, 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_imap_smtp_access_servers" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/inboxes/imap-smtp-access/servers', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ImapSmtpAccessServers',  # 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(self, inbox_id, **kwargs):  # noqa: E501
        """Get Inbox. Returns properties of an inbox.  # noqa: E501

        Returns an inbox's properties, including its email address and ID.  # 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(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :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: InboxDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def get_inbox_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """Get Inbox. Returns properties of an inbox.  # noqa: E501

        Returns an inbox's properties, including its email address and ID.  # 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_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_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: tuple(InboxDto, status_code(int), headers(HTTPHeaderDict))
                 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 get_inbox" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `get_inbox`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/inboxes/{inboxId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxDto',  # 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_by_email_address(self, email_address, **kwargs):  # noqa: E501
        """Search for an inbox with the provided email address  # noqa: E501

        Get a inbox result by email address  # 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_by_email_address(email_address, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_address: (required)
        :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: InboxByEmailAddressResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_by_email_address_with_http_info(email_address, **kwargs)  # noqa: E501

    def get_inbox_by_email_address_with_http_info(self, email_address, **kwargs):  # noqa: E501
        """Search for an inbox with the provided email address  # noqa: E501

        Get a inbox result by email address  # 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_by_email_address_with_http_info(email_address, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_address: (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(InboxByEmailAddressResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_address'
        ]
        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_by_email_address" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_address' is set
        if self.api_client.client_side_validation and ('email_address' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_address'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_address` when calling `get_inbox_by_email_address`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'email_address' in local_var_params and local_var_params['email_address'] is not None:  # noqa: E501
            query_params.append(('emailAddress', local_var_params['email_address']))  # 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(
            '/inboxes/byEmailAddress', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxByEmailAddressResult',  # 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_by_name(self, name, **kwargs):  # noqa: E501
        """Search for an inbox with the given name  # noqa: E501

        Get a inbox result by name  # 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_by_name(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str name: (required)
        :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: InboxByNameResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_by_name_with_http_info(name, **kwargs)  # noqa: E501

    def get_inbox_by_name_with_http_info(self, name, **kwargs):  # noqa: E501
        """Search for an inbox with the given name  # noqa: E501

        Get a inbox result by name  # 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_by_name_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str name: (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(InboxByNameResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'name'
        ]
        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_by_name" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'name' is set
        if self.api_client.client_side_validation and ('name' not in local_var_params or  # noqa: E501
                                                        local_var_params['name'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `name` when calling `get_inbox_by_name`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'name' in local_var_params and local_var_params['name'] is not None:  # noqa: E501
            query_params.append(('name', local_var_params['name']))  # 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(
            '/inboxes/byName', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxByNameResult',  # 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_count(self, **kwargs):  # noqa: E501
        """Get total inbox count  # 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_count(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: CountDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_count_with_http_info(**kwargs)  # noqa: E501

    def get_inbox_count_with_http_info(self, **kwargs):  # noqa: E501
        """Get total inbox count  # 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_count_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(CountDto, 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_inbox_count" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/inboxes/count', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CountDto',  # 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_email_count(self, inbox_id, **kwargs):  # noqa: E501
        """Get email count in 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_email_count(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Id of inbox that emails belongs to (required)
        :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: CountDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_email_count_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def get_inbox_email_count_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """Get email count in 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_email_count_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Id of inbox that emails belongs to (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(CountDto, status_code(int), headers(HTTPHeaderDict))
                 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 get_inbox_email_count" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `get_inbox_email_count`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/inboxes/{inboxId}/emails/count', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CountDto',  # 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_emails_paginated(self, inbox_id, **kwargs):  # noqa: E501
        """Get inbox emails paginated  # noqa: E501

        Get a paginated list of emails in an inbox. Does not hold connections open.  # 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_emails_paginated(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Id of inbox that emails belongs to (required)
        :param int page: Optional page index in inbox emails list pagination
        :param int size: Optional page size in inbox emails list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Optional filter by received after given date time
        :param datetime before: Optional filter by received before given date time
        :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: PageEmailPreview
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_emails_paginated_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def get_inbox_emails_paginated_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """Get inbox emails paginated  # noqa: E501

        Get a paginated list of emails in an inbox. Does not hold connections open.  # 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_emails_paginated_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Id of inbox that emails belongs to (required)
        :param int page: Optional page index in inbox emails list pagination
        :param int size: Optional page size in inbox emails list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Optional filter by received after given date time
        :param datetime before: Optional filter by received before given date 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(PageEmailPreview, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort',
            '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 get_inbox_emails_paginated" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `get_inbox_emails_paginated`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_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
        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(
            '/inboxes/{inboxId}/emails/paginated', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageEmailPreview',  # 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_ids(self, **kwargs):  # noqa: E501
        """Get all inbox IDs  # noqa: E501

        Get list of inbox IDs  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_inbox_ids(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: InboxIdsResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_ids_with_http_info(**kwargs)  # noqa: E501

    def get_inbox_ids_with_http_info(self, **kwargs):  # noqa: E501
        """Get all inbox IDs  # noqa: E501

        Get list of inbox IDs  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_inbox_ids_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(InboxIdsResult, 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_inbox_ids" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/inboxes/ids', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxIdsResult',  # 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_sent_emails(self, inbox_id, **kwargs):  # noqa: E501
        """Get Inbox Sent Emails  # noqa: E501

        Returns an inbox's sent email receipts. Call individual sent email endpoints for more details. Note for privacy reasons the full body of sent emails is never stored. An MD5 hash hex is available for comparison instead.  # 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_sent_emails(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :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 str search_filter: Optional sent email search
        :param datetime since: Optional filter by sent after given date time
        :param datetime before: Optional filter by sent before given date time
        :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: PageSentEmailProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_sent_emails_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def get_inbox_sent_emails_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """Get Inbox Sent Emails  # noqa: E501

        Returns an inbox's sent email receipts. Call individual sent email endpoints for more details. Note for privacy reasons the full body of sent emails is never stored. An MD5 hash hex is available for comparison instead.  # 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_sent_emails_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :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 str search_filter: Optional sent email search
        :param datetime since: Optional filter by sent after given date time
        :param datetime before: Optional filter by sent before given date 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(PageSentEmailProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort',
            'search_filter',
            '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 get_inbox_sent_emails" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `get_inbox_sent_emails`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_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
        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

        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(
            '/inboxes/{inboxId}/sent', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageSentEmailProjection',  # 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_tags(self, **kwargs):  # noqa: E501
        """Get inbox tags  # noqa: E501

        Get all inbox tags  # 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_tags(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inbox_tags_with_http_info(**kwargs)  # noqa: E501

    def get_inbox_tags_with_http_info(self, **kwargs):  # noqa: E501
        """Get inbox tags  # noqa: E501

        Get all inbox tags  # 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_tags_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(list[str], 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_inbox_tags" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/inboxes/tags', '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 get_inboxes(self, **kwargs):  # noqa: E501
        """List Inboxes and email addresses  # noqa: E501

        List the inboxes you have created. Note use of the more advanced `getAllInboxes` is recommended and allows paginated access using a limit and sort parameter.  # 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_inboxes(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int size: Optional result size limit. Note an automatic limit of 100 results is applied. See the paginated `getAllEmails` for larger queries.
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Optional filter by created after given date time
        :param bool exclude_catch_all_inboxes: Optional exclude catch all inboxes
        :param datetime before: Optional filter by created before given date time
        :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: list[InboxDto]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_inboxes_with_http_info(**kwargs)  # noqa: E501

    def get_inboxes_with_http_info(self, **kwargs):  # noqa: E501
        """List Inboxes and email addresses  # noqa: E501

        List the inboxes you have created. Note use of the more advanced `getAllInboxes` is recommended and allows paginated access using a limit and sort parameter.  # 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_inboxes_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int size: Optional result size limit. Note an automatic limit of 100 results is applied. See the paginated `getAllEmails` for larger queries.
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Optional filter by created after given date time
        :param bool exclude_catch_all_inboxes: Optional exclude catch all inboxes
        :param datetime before: Optional filter by created before given date 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[InboxDto], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'size',
            'sort',
            'since',
            'exclude_catch_all_inboxes',
            '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 get_inboxes" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        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_inboxes`, must be a value less than or equal to `100`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        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 '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 'exclude_catch_all_inboxes' in local_var_params and local_var_params['exclude_catch_all_inboxes'] is not None:  # noqa: E501
            query_params.append(('excludeCatchAllInboxes', local_var_params['exclude_catch_all_inboxes']))  # 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(
            '/inboxes', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[InboxDto]',  # 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_latest_email_in_inbox(self, inbox_id, timeout_millis, **kwargs):  # noqa: E501
        """Get latest email in an inbox. Use `WaitForController` to get emails that may not have arrived yet.  # noqa: E501

        Get the newest email in an inbox or wait for one to arrive  # 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_latest_email_in_inbox(inbox_id, timeout_millis, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of the inbox you want to get the latest email from (required)
        :param int timeout_millis: Timeout milliseconds to wait for latest email (required)
        :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: Email
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_latest_email_in_inbox_with_http_info(inbox_id, timeout_millis, **kwargs)  # noqa: E501

    def get_latest_email_in_inbox_with_http_info(self, inbox_id, timeout_millis, **kwargs):  # noqa: E501
        """Get latest email in an inbox. Use `WaitForController` to get emails that may not have arrived yet.  # noqa: E501

        Get the newest email in an inbox or wait for one to arrive  # 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_latest_email_in_inbox_with_http_info(inbox_id, timeout_millis, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of the inbox you want to get the latest email from (required)
        :param int timeout_millis: Timeout milliseconds to wait for latest email (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(Email, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'timeout_millis'
        ]
        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_latest_email_in_inbox" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `get_latest_email_in_inbox`")  # noqa: E501
        # verify the required parameter 'timeout_millis' is set
        if self.api_client.client_side_validation and ('timeout_millis' not in local_var_params or  # noqa: E501
                                                        local_var_params['timeout_millis'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `timeout_millis` when calling `get_latest_email_in_inbox`")  # 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_millis' in local_var_params and local_var_params['timeout_millis'] is not None:  # noqa: E501
            query_params.append(('timeoutMillis', local_var_params['timeout_millis']))  # 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(
            '/inboxes/getLatestEmail', '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_organization_inboxes(self, **kwargs):  # noqa: E501
        """List Organization Inboxes Paginated  # noqa: E501

        List organization inboxes in paginated form. These are inboxes created with `allowTeamAccess` flag enabled. Organization inboxes are `readOnly` for non-admin users. The results are available on the `content` property of the returned object. This method allows for page index (zero based), page size (how many results to return), and a sort direction (based on createdAt time).   # 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_organization_inboxes(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 in list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param str search_filter: Optional search filter
        :param datetime since: Optional filter by created after given date time
        :param datetime before: Optional filter by created before given date time
        :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: PageOrganizationInboxProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_organization_inboxes_with_http_info(**kwargs)  # noqa: E501

    def get_organization_inboxes_with_http_info(self, **kwargs):  # noqa: E501
        """List Organization Inboxes Paginated  # noqa: E501

        List organization inboxes in paginated form. These are inboxes created with `allowTeamAccess` flag enabled. Organization inboxes are `readOnly` for non-admin users. The results are available on the `content` property of the returned object. This method allows for page index (zero based), page size (how many results to return), and a sort direction (based on createdAt time).   # 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_organization_inboxes_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 in list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param str search_filter: Optional search filter
        :param datetime since: Optional filter by created after given date time
        :param datetime before: Optional filter by created before given date 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(PageOrganizationInboxProjection, 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'
        ]
        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_organization_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
        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

        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(
            '/inboxes/organization', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageOrganizationInboxProjection',  # 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_scheduled_job(self, job_id, **kwargs):  # noqa: E501
        """Get a scheduled email job  # noqa: E501

        Get a scheduled email job details.  # 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_scheduled_job(job_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str job_id: (required)
        :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: ScheduledJobDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_scheduled_job_with_http_info(job_id, **kwargs)  # noqa: E501

    def get_scheduled_job_with_http_info(self, job_id, **kwargs):  # noqa: E501
        """Get a scheduled email job  # noqa: E501

        Get a scheduled email job details.  # 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_scheduled_job_with_http_info(job_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str job_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: tuple(ScheduledJobDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'job_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_scheduled_job" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'job_id' is set
        if self.api_client.client_side_validation and ('job_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['job_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `job_id` when calling `get_scheduled_job`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'job_id' in local_var_params:
            path_params['jobId'] = local_var_params['job_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/inboxes/scheduled-jobs/{jobId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ScheduledJobDto',  # 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_scheduled_jobs_by_inbox_id(self, inbox_id, **kwargs):  # noqa: E501
        """Get all scheduled email sending jobs for the inbox  # noqa: E501

        Schedule sending of emails using scheduled jobs.  # 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_scheduled_jobs_by_inbox_id(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param int page: Optional page index in scheduled job list pagination
        :param int size: Optional page size in scheduled job list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageScheduledJobs
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_scheduled_jobs_by_inbox_id_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def get_scheduled_jobs_by_inbox_id_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """Get all scheduled email sending jobs for the inbox  # noqa: E501

        Schedule sending of emails using scheduled jobs.  # 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_scheduled_jobs_by_inbox_id_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param int page: Optional page index in scheduled job list pagination
        :param int size: Optional page size in scheduled job list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PageScheduledJobs, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort',
            '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 get_scheduled_jobs_by_inbox_id" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `get_scheduled_jobs_by_inbox_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_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
        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(
            '/inboxes/{inboxId}/scheduled-jobs', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageScheduledJobs',  # 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_smtp_access(self, **kwargs):  # noqa: E501
        """get_smtp_access  # noqa: E501

        Get SMTP access usernames and passwords  # 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_smtp_access(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Inbox ID
        :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: SmtpAccessDetails
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_smtp_access_with_http_info(**kwargs)  # noqa: E501

    def get_smtp_access_with_http_info(self, **kwargs):  # noqa: E501
        """get_smtp_access  # noqa: E501

        Get SMTP access usernames and passwords  # 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_smtp_access_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Inbox ID
        :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(SmtpAccessDetails, status_code(int), headers(HTTPHeaderDict))
                 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 get_smtp_access" % 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
        # 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(
            '/inboxes/smtp-access', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SmtpAccessDetails',  # 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 is_email_address_available(self, email_address, **kwargs):  # noqa: E501
        """Is email address available  # noqa: E501

        Returns whether an email address is available  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.is_email_address_available(email_address, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_address: (required)
        :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: EmailAvailableResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.is_email_address_available_with_http_info(email_address, **kwargs)  # noqa: E501

    def is_email_address_available_with_http_info(self, email_address, **kwargs):  # noqa: E501
        """Is email address available  # noqa: E501

        Returns whether an email address is available  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.is_email_address_available_with_http_info(email_address, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_address: (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(EmailAvailableResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_address'
        ]
        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 is_email_address_available" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_address' is set
        if self.api_client.client_side_validation and ('email_address' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_address'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_address` when calling `is_email_address_available`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'email_address' in local_var_params and local_var_params['email_address'] is not None:  # noqa: E501
            query_params.append(('emailAddress', local_var_params['email_address']))  # 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(
            '/inboxes/available', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmailAvailableResult',  # 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 list_inbox_rulesets(self, inbox_id, **kwargs):  # noqa: E501
        """List inbox rulesets  # noqa: E501

        List all rulesets 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.list_inbox_rulesets(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param int page: Optional page index in inbox ruleset list pagination
        :param int size: Optional page size in inbox ruleset list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param str search_filter: Optional search filter
        :param datetime since: Optional filter by created after given date time
        :param datetime before: Optional filter by created before given date time
        :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: PageInboxRulesetDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_inbox_rulesets_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def list_inbox_rulesets_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """List inbox rulesets  # noqa: E501

        List all rulesets 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.list_inbox_rulesets_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param int page: Optional page index in inbox ruleset list pagination
        :param int size: Optional page size in inbox ruleset list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param str search_filter: Optional search filter
        :param datetime since: Optional filter by created after given date time
        :param datetime before: Optional filter by created before given date 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(PageInboxRulesetDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort',
            'search_filter',
            '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 list_inbox_rulesets" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `list_inbox_rulesets`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_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
        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

        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(
            '/inboxes/{inboxId}/rulesets', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageInboxRulesetDto',  # 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 list_inbox_tracking_pixels(self, inbox_id, **kwargs):  # noqa: E501
        """List inbox tracking pixels  # noqa: E501

        List all tracking pixels sent from 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.list_inbox_tracking_pixels(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param int page: Optional page index in inbox tracking pixel list pagination
        :param int size: Optional page size in inbox tracking pixel list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param str search_filter: Optional search filter
        :param datetime since: Optional filter by created after given date time
        :param datetime before: Optional filter by created before given date time
        :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: PageTrackingPixelProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_inbox_tracking_pixels_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def list_inbox_tracking_pixels_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """List inbox tracking pixels  # noqa: E501

        List all tracking pixels sent from 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.list_inbox_tracking_pixels_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param int page: Optional page index in inbox tracking pixel list pagination
        :param int size: Optional page size in inbox tracking pixel list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param str search_filter: Optional search filter
        :param datetime since: Optional filter by created after given date time
        :param datetime before: Optional filter by created before given date 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(PageTrackingPixelProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort',
            'search_filter',
            '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 list_inbox_tracking_pixels" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `list_inbox_tracking_pixels`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_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
        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

        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(
            '/inboxes/{inboxId}/tracking-pixels', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageTrackingPixelProjection',  # 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 search_inboxes(self, search_inboxes_options, **kwargs):  # noqa: E501
        """Search all inboxes and return matching inboxes  # noqa: E501

        Search inboxes and return in paginated form. The results are available on the `content` property of the returned object. This method allows for page index (zero based), page size (how many results to return), and a sort direction (based on createdAt time). You Can also filter by whether an inbox is favorited or use email address pattern. This method is the recommended way to query inboxes. The alternative `getInboxes` method returns a full list of inboxes but is limited to 100 results.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.search_inboxes(search_inboxes_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param SearchInboxesOptions search_inboxes_options: (required)
        :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: PageInboxProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.search_inboxes_with_http_info(search_inboxes_options, **kwargs)  # noqa: E501

    def search_inboxes_with_http_info(self, search_inboxes_options, **kwargs):  # noqa: E501
        """Search all inboxes and return matching inboxes  # noqa: E501

        Search inboxes and return in paginated form. The results are available on the `content` property of the returned object. This method allows for page index (zero based), page size (how many results to return), and a sort direction (based on createdAt time). You Can also filter by whether an inbox is favorited or use email address pattern. This method is the recommended way to query inboxes. The alternative `getInboxes` method returns a full list of inboxes but is limited to 100 results.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.search_inboxes_with_http_info(search_inboxes_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param SearchInboxesOptions search_inboxes_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(PageInboxProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'search_inboxes_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 search_inboxes" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'search_inboxes_options' is set
        if self.api_client.client_side_validation and ('search_inboxes_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['search_inboxes_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `search_inboxes_options` when calling `search_inboxes`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'search_inboxes_options' in local_var_params:
            body_params = local_var_params['search_inboxes_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(
            '/inboxes/search', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageInboxProjection',  # 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 send_email(self, inbox_id, send_email_options, **kwargs):  # noqa: E501
        """Send Email  # noqa: E501

        Send an email from an inbox's email address.  The request body should contain the `SendEmailOptions` that include recipients, attachments, body etc. See `SendEmailOptions` for all available properties. Note the `inboxId` refers to the inbox's id not the inbox's email address. See https://www.mailslurp.com/guides/ for more information on how to send emails. This method does not return a sent email entity due to legacy reasons. To send and get a sent email as returned response use the sister method `sendEmailAndConfirm`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.send_email(inbox_id, send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of the inbox you want to send the email from (required)
        :param SendEmailOptions send_email_options: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.send_email_with_http_info(inbox_id, send_email_options, **kwargs)  # noqa: E501

    def send_email_with_http_info(self, inbox_id, send_email_options, **kwargs):  # noqa: E501
        """Send Email  # noqa: E501

        Send an email from an inbox's email address.  The request body should contain the `SendEmailOptions` that include recipients, attachments, body etc. See `SendEmailOptions` for all available properties. Note the `inboxId` refers to the inbox's id not the inbox's email address. See https://www.mailslurp.com/guides/ for more information on how to send emails. This method does not return a sent email entity due to legacy reasons. To send and get a sent email as returned response use the sister method `sendEmailAndConfirm`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.send_email_with_http_info(inbox_id, send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of the inbox you want to send the email from (required)
        :param SendEmailOptions send_email_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: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            '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 send_email" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `send_email`")  # noqa: E501
        # verify the required parameter 'send_email_options' is set
        if self.api_client.client_side_validation and ('send_email_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['send_email_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `send_email_options` when calling `send_email`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'send_email_options' in local_var_params:
            body_params = local_var_params['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(
            '/inboxes/{inboxId}', '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 send_email_and_confirm(self, inbox_id, send_email_options, **kwargs):  # noqa: E501
        """Send email and return sent confirmation  # noqa: E501

        Sister method for standard `sendEmail` method with the benefit of returning a `SentEmail` entity confirming the successful sending of the email with a link to the sent object created for 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.send_email_and_confirm(inbox_id, send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of the inbox you want to send the email from (required)
        :param SendEmailOptions send_email_options: (required)
        :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: SentEmailDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.send_email_and_confirm_with_http_info(inbox_id, send_email_options, **kwargs)  # noqa: E501

    def send_email_and_confirm_with_http_info(self, inbox_id, send_email_options, **kwargs):  # noqa: E501
        """Send email and return sent confirmation  # noqa: E501

        Sister method for standard `sendEmail` method with the benefit of returning a `SentEmail` entity confirming the successful sending of the email with a link to the sent object created for 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.send_email_and_confirm_with_http_info(inbox_id, send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of the inbox you want to send the email from (required)
        :param SendEmailOptions send_email_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(SentEmailDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            '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 send_email_and_confirm" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `send_email_and_confirm`")  # noqa: E501
        # verify the required parameter 'send_email_options' is set
        if self.api_client.client_side_validation and ('send_email_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['send_email_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `send_email_options` when calling `send_email_and_confirm`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'send_email_options' in local_var_params:
            body_params = local_var_params['send_email_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(
            '/inboxes/{inboxId}/confirm', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SentEmailDto',  # 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 send_email_with_queue(self, inbox_id, validate_before_enqueue, send_email_options, **kwargs):  # noqa: E501
        """Send email with queue  # noqa: E501

        Send an email using a queue. Will place the email onto a queue that will then be processed and sent. Use this queue method to enable any failed email sending to be recovered. This will prevent lost emails when sending if your account encounters a block or payment issue.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.send_email_with_queue(inbox_id, validate_before_enqueue, send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of the inbox you want to send the email from (required)
        :param bool validate_before_enqueue: Validate before adding to queue (required)
        :param SendEmailOptions send_email_options: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.send_email_with_queue_with_http_info(inbox_id, validate_before_enqueue, send_email_options, **kwargs)  # noqa: E501

    def send_email_with_queue_with_http_info(self, inbox_id, validate_before_enqueue, send_email_options, **kwargs):  # noqa: E501
        """Send email with queue  # noqa: E501

        Send an email using a queue. Will place the email onto a queue that will then be processed and sent. Use this queue method to enable any failed email sending to be recovered. This will prevent lost emails when sending if your account encounters a block or payment issue.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.send_email_with_queue_with_http_info(inbox_id, validate_before_enqueue, send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of the inbox you want to send the email from (required)
        :param bool validate_before_enqueue: Validate before adding to queue (required)
        :param SendEmailOptions send_email_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: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'validate_before_enqueue',
            '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 send_email_with_queue" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `send_email_with_queue`")  # noqa: E501
        # verify the required parameter 'validate_before_enqueue' is set
        if self.api_client.client_side_validation and ('validate_before_enqueue' not in local_var_params or  # noqa: E501
                                                        local_var_params['validate_before_enqueue'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `validate_before_enqueue` when calling `send_email_with_queue`")  # noqa: E501
        # verify the required parameter 'send_email_options' is set
        if self.api_client.client_side_validation and ('send_email_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['send_email_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `send_email_options` when calling `send_email_with_queue`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []
        if 'validate_before_enqueue' in local_var_params and local_var_params['validate_before_enqueue'] is not None:  # noqa: E501
            query_params.append(('validateBeforeEnqueue', local_var_params['validate_before_enqueue']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'send_email_options' in local_var_params:
            body_params = local_var_params['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(
            '/inboxes/{inboxId}/with-queue', '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 send_smtp_envelope(self, inbox_id, send_smtp_envelope_options, **kwargs):  # noqa: E501
        """Send email using an SMTP mail envelope and message body and return sent confirmation  # noqa: E501

        Send email using an SMTP envelope containing RCPT TO, MAIL FROM, and a SMTP BODY.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.send_smtp_envelope(inbox_id, send_smtp_envelope_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of the inbox you want to send the email from (required)
        :param SendSMTPEnvelopeOptions send_smtp_envelope_options: (required)
        :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: SentEmailDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.send_smtp_envelope_with_http_info(inbox_id, send_smtp_envelope_options, **kwargs)  # noqa: E501

    def send_smtp_envelope_with_http_info(self, inbox_id, send_smtp_envelope_options, **kwargs):  # noqa: E501
        """Send email using an SMTP mail envelope and message body and return sent confirmation  # noqa: E501

        Send email using an SMTP envelope containing RCPT TO, MAIL FROM, and a SMTP BODY.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.send_smtp_envelope_with_http_info(inbox_id, send_smtp_envelope_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of the inbox you want to send the email from (required)
        :param SendSMTPEnvelopeOptions send_smtp_envelope_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(SentEmailDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'send_smtp_envelope_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 send_smtp_envelope" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `send_smtp_envelope`")  # noqa: E501
        # verify the required parameter 'send_smtp_envelope_options' is set
        if self.api_client.client_side_validation and ('send_smtp_envelope_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['send_smtp_envelope_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `send_smtp_envelope_options` when calling `send_smtp_envelope`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'send_smtp_envelope_options' in local_var_params:
            body_params = local_var_params['send_smtp_envelope_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(
            '/inboxes/{inboxId}/smtp-envelope', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SentEmailDto',  # 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 send_test_email(self, inbox_id, **kwargs):  # noqa: E501
        """Send a test email to inbox  # noqa: E501

        Send an inbox a test email to test email receiving is working  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.send_test_email(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.send_test_email_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def send_test_email_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """Send a test email to inbox  # noqa: E501

        Send an inbox a test email to test email receiving is working  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.send_test_email_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_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 = [
            '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 send_test_email" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `send_test_email`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_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(
            '/inboxes/{inboxId}/send-test-email', '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 send_with_schedule(self, inbox_id, send_email_options, **kwargs):  # noqa: E501
        """Send email with with delay or schedule  # noqa: E501

        Send an email using a delay. Will place the email onto a scheduler that will then be processed and sent. Use delays to schedule email sending.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.send_with_schedule(inbox_id, send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of the inbox you want to send the email from (required)
        :param SendEmailOptions send_email_options: (required)
        :param datetime send_at_timestamp: Sending timestamp
        :param int send_at_now_plus_seconds: Send after n seconds
        :param bool validate_before_enqueue: Validate before adding to queue
        :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: ScheduledJobDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.send_with_schedule_with_http_info(inbox_id, send_email_options, **kwargs)  # noqa: E501

    def send_with_schedule_with_http_info(self, inbox_id, send_email_options, **kwargs):  # noqa: E501
        """Send email with with delay or schedule  # noqa: E501

        Send an email using a delay. Will place the email onto a scheduler that will then be processed and sent. Use delays to schedule email sending.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.send_with_schedule_with_http_info(inbox_id, send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of the inbox you want to send the email from (required)
        :param SendEmailOptions send_email_options: (required)
        :param datetime send_at_timestamp: Sending timestamp
        :param int send_at_now_plus_seconds: Send after n seconds
        :param bool validate_before_enqueue: Validate before adding to queue
        :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(ScheduledJobDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'send_email_options',
            'send_at_timestamp',
            'send_at_now_plus_seconds',
            'validate_before_enqueue'
        ]
        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 send_with_schedule" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `send_with_schedule`")  # noqa: E501
        # verify the required parameter 'send_email_options' is set
        if self.api_client.client_side_validation and ('send_email_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['send_email_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `send_email_options` when calling `send_with_schedule`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []
        if 'send_at_timestamp' in local_var_params and local_var_params['send_at_timestamp'] is not None:  # noqa: E501
            query_params.append(('sendAtTimestamp', local_var_params['send_at_timestamp']))  # noqa: E501
        if 'send_at_now_plus_seconds' in local_var_params and local_var_params['send_at_now_plus_seconds'] is not None:  # noqa: E501
            query_params.append(('sendAtNowPlusSeconds', local_var_params['send_at_now_plus_seconds']))  # noqa: E501
        if 'validate_before_enqueue' in local_var_params and local_var_params['validate_before_enqueue'] is not None:  # noqa: E501
            query_params.append(('validateBeforeEnqueue', local_var_params['validate_before_enqueue']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'send_email_options' in local_var_params:
            body_params = local_var_params['send_email_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(
            '/inboxes/{inboxId}/with-schedule', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ScheduledJobDto',  # 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 set_inbox_favourited(self, inbox_id, set_inbox_favourited_options, **kwargs):  # noqa: E501
        """Set inbox favourited state  # noqa: E501

        Set and return new favourite state for 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.set_inbox_favourited(inbox_id, set_inbox_favourited_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox to set favourite state (required)
        :param SetInboxFavouritedOptions set_inbox_favourited_options: (required)
        :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: InboxDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.set_inbox_favourited_with_http_info(inbox_id, set_inbox_favourited_options, **kwargs)  # noqa: E501

    def set_inbox_favourited_with_http_info(self, inbox_id, set_inbox_favourited_options, **kwargs):  # noqa: E501
        """Set inbox favourited state  # noqa: E501

        Set and return new favourite state for 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.set_inbox_favourited_with_http_info(inbox_id, set_inbox_favourited_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox to set favourite state (required)
        :param SetInboxFavouritedOptions set_inbox_favourited_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(InboxDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'set_inbox_favourited_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 set_inbox_favourited" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `set_inbox_favourited`")  # noqa: E501
        # verify the required parameter 'set_inbox_favourited_options' is set
        if self.api_client.client_side_validation and ('set_inbox_favourited_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['set_inbox_favourited_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `set_inbox_favourited_options` when calling `set_inbox_favourited`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'set_inbox_favourited_options' in local_var_params:
            body_params = local_var_params['set_inbox_favourited_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(
            '/inboxes/{inboxId}/favourite', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxDto',  # 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_imap_access(self, update_imap_access_options, **kwargs):  # noqa: E501
        """update_imap_access  # noqa: E501

        Update IMAP access usernames and passwords  # 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_imap_access(update_imap_access_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UpdateImapAccessOptions update_imap_access_options: (required)
        :param str inbox_id: Inbox ID
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_imap_access_with_http_info(update_imap_access_options, **kwargs)  # noqa: E501

    def update_imap_access_with_http_info(self, update_imap_access_options, **kwargs):  # noqa: E501
        """update_imap_access  # noqa: E501

        Update IMAP access usernames and passwords  # 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_imap_access_with_http_info(update_imap_access_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UpdateImapAccessOptions update_imap_access_options: (required)
        :param str inbox_id: Inbox ID
        :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 = [
            'update_imap_access_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 update_imap_access" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'update_imap_access_options' is set
        if self.api_client.client_side_validation and ('update_imap_access_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['update_imap_access_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `update_imap_access_options` when calling `update_imap_access`")  # 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 'update_imap_access_options' in local_var_params:
            body_params = local_var_params['update_imap_access_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(
            '/inboxes/imap-access', 'PATCH',
            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 update_inbox(self, inbox_id, update_inbox_options, **kwargs):  # noqa: E501
        """Update Inbox. Change name and description. Email address is not editable.  # noqa: E501

        Update editable fields on 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.update_inbox(inbox_id, update_inbox_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param UpdateInboxOptions update_inbox_options: (required)
        :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: InboxDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_inbox_with_http_info(inbox_id, update_inbox_options, **kwargs)  # noqa: E501

    def update_inbox_with_http_info(self, inbox_id, update_inbox_options, **kwargs):  # noqa: E501
        """Update Inbox. Change name and description. Email address is not editable.  # noqa: E501

        Update editable fields on 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.update_inbox_with_http_info(inbox_id, update_inbox_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param UpdateInboxOptions update_inbox_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(InboxDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'update_inbox_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_inbox" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `update_inbox`")  # noqa: E501
        # verify the required parameter 'update_inbox_options' is set
        if self.api_client.client_side_validation and ('update_inbox_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['update_inbox_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `update_inbox_options` when calling `update_inbox`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'update_inbox_options' in local_var_params:
            body_params = local_var_params['update_inbox_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(
            '/inboxes/{inboxId}', 'PATCH',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxDto',  # 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_smtp_access(self, update_smtp_access_options, **kwargs):  # noqa: E501
        """update_smtp_access  # noqa: E501

        Update SMTP access usernames and passwords  # 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_smtp_access(update_smtp_access_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UpdateSmtpAccessOptions update_smtp_access_options: (required)
        :param str inbox_id: Inbox ID
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_smtp_access_with_http_info(update_smtp_access_options, **kwargs)  # noqa: E501

    def update_smtp_access_with_http_info(self, update_smtp_access_options, **kwargs):  # noqa: E501
        """update_smtp_access  # noqa: E501

        Update SMTP access usernames and passwords  # 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_smtp_access_with_http_info(update_smtp_access_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UpdateSmtpAccessOptions update_smtp_access_options: (required)
        :param str inbox_id: Inbox ID
        :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 = [
            'update_smtp_access_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 update_smtp_access" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'update_smtp_access_options' is set
        if self.api_client.client_side_validation and ('update_smtp_access_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['update_smtp_access_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `update_smtp_access_options` when calling `update_smtp_access`")  # 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 'update_smtp_access_options' in local_var_params:
            body_params = local_var_params['update_smtp_access_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(
            '/inboxes/smtp-access', 'PATCH',
            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)

mailslurp_client/api/imap_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class ImapControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def imap_server_fetch(self, seq_num, **kwargs):  # noqa: E501
        """Fetch message in 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.imap_server_fetch(seq_num, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int seq_num: (required)
        :param str inbox_id: Inbox ID to search
        :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: ImapServerFetchResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.imap_server_fetch_with_http_info(seq_num, **kwargs)  # noqa: E501

    def imap_server_fetch_with_http_info(self, seq_num, **kwargs):  # noqa: E501
        """Fetch message in 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.imap_server_fetch_with_http_info(seq_num, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int seq_num: (required)
        :param str inbox_id: Inbox ID to search
        :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(ImapServerFetchResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'seq_num',
            '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 imap_server_fetch" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'seq_num' is set
        if self.api_client.client_side_validation and ('seq_num' not in local_var_params or  # noqa: E501
                                                        local_var_params['seq_num'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `seq_num` when calling `imap_server_fetch`")  # 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 'seq_num' in local_var_params and local_var_params['seq_num'] is not None:  # noqa: E501
            query_params.append(('seqNum', local_var_params['seq_num']))  # 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(
            '/imap/server/fetch', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ImapServerFetchResult',  # 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 imap_server_get(self, email_id, **kwargs):  # noqa: E501
        """Get a message by email ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.imap_server_get(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: Email ID to get (required)
        :param str inbox_id: Inbox ID to search
        :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: ImapServerGetResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.imap_server_get_with_http_info(email_id, **kwargs)  # noqa: E501

    def imap_server_get_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Get a message by email ID  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.imap_server_get_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: Email ID to get (required)
        :param str inbox_id: Inbox ID to search
        :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(ImapServerGetResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            '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 imap_server_get" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `imap_server_get`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'email_id' in local_var_params and local_var_params['email_id'] is not None:  # noqa: E501
            query_params.append(('emailId', local_var_params['email_id']))  # 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

        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(
            '/imap/server/get', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ImapServerGetResult',  # 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 imap_server_list(self, imap_server_list_options, **kwargs):  # noqa: E501
        """List messages in 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.imap_server_list(imap_server_list_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param ImapServerListOptions imap_server_list_options: (required)
        :param str inbox_id: Inbox ID to list
        :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: ImapServerListResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.imap_server_list_with_http_info(imap_server_list_options, **kwargs)  # noqa: E501

    def imap_server_list_with_http_info(self, imap_server_list_options, **kwargs):  # noqa: E501
        """List messages in 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.imap_server_list_with_http_info(imap_server_list_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param ImapServerListOptions imap_server_list_options: (required)
        :param str inbox_id: Inbox ID to list
        :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(ImapServerListResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'imap_server_list_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 imap_server_list" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'imap_server_list_options' is set
        if self.api_client.client_side_validation and ('imap_server_list_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['imap_server_list_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `imap_server_list_options` when calling `imap_server_list`")  # 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 'imap_server_list_options' in local_var_params:
            body_params = local_var_params['imap_server_list_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(
            '/imap/server/list', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ImapServerListResult',  # 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 imap_server_mailbox(self, name, **kwargs):  # noqa: E501
        """Create a new mailbox if possible  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.imap_server_mailbox(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str name: Inbox email address to create (required)
        :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: ImapServerMailboxResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.imap_server_mailbox_with_http_info(name, **kwargs)  # noqa: E501

    def imap_server_mailbox_with_http_info(self, name, **kwargs):  # noqa: E501
        """Create a new mailbox if possible  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.imap_server_mailbox_with_http_info(name, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str name: Inbox email address to create (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(ImapServerMailboxResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'name'
        ]
        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 imap_server_mailbox" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'name' is set
        if self.api_client.client_side_validation and ('name' not in local_var_params or  # noqa: E501
                                                        local_var_params['name'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `name` when calling `imap_server_mailbox`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'name' in local_var_params and local_var_params['name'] is not None:  # noqa: E501
            query_params.append(('name', local_var_params['name']))  # 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(
            '/imap/server/mailbox', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ImapServerMailboxResult',  # 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 imap_server_search(self, imap_server_search_options, **kwargs):  # noqa: E501
        """Search messages in 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.imap_server_search(imap_server_search_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param ImapServerSearchOptions imap_server_search_options: (required)
        :param str inbox_id: Inbox ID to search
        :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: ImapServerSearchResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.imap_server_search_with_http_info(imap_server_search_options, **kwargs)  # noqa: E501

    def imap_server_search_with_http_info(self, imap_server_search_options, **kwargs):  # noqa: E501
        """Search messages in 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.imap_server_search_with_http_info(imap_server_search_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param ImapServerSearchOptions imap_server_search_options: (required)
        :param str inbox_id: Inbox ID to search
        :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(ImapServerSearchResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'imap_server_search_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 imap_server_search" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'imap_server_search_options' is set
        if self.api_client.client_side_validation and ('imap_server_search_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['imap_server_search_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `imap_server_search_options` when calling `imap_server_search`")  # 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 'imap_server_search_options' in local_var_params:
            body_params = local_var_params['imap_server_search_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(
            '/imap/server/search', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ImapServerSearchResult',  # 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 imap_server_status(self, imap_server_status_options, **kwargs):  # noqa: E501
        """Get status for mailbox  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.imap_server_status(imap_server_status_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param ImapServerStatusOptions imap_server_status_options: (required)
        :param str inbox_id: Inbox ID to list
        :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: ImapServerStatusResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.imap_server_status_with_http_info(imap_server_status_options, **kwargs)  # noqa: E501

    def imap_server_status_with_http_info(self, imap_server_status_options, **kwargs):  # noqa: E501
        """Get status for mailbox  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.imap_server_status_with_http_info(imap_server_status_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param ImapServerStatusOptions imap_server_status_options: (required)
        :param str inbox_id: Inbox ID to list
        :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(ImapServerStatusResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'imap_server_status_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 imap_server_status" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'imap_server_status_options' is set
        if self.api_client.client_side_validation and ('imap_server_status_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['imap_server_status_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `imap_server_status_options` when calling `imap_server_status`")  # 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 'imap_server_status_options' in local_var_params:
            body_params = local_var_params['imap_server_status_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(
            '/imap/server/status', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ImapServerStatusResult',  # 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 imap_server_update_flags(self, imap_update_flags_options, **kwargs):  # noqa: E501
        """imap_server_update_flags  # noqa: E501

        Update message flags  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.imap_server_update_flags(imap_update_flags_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param ImapUpdateFlagsOptions imap_update_flags_options: (required)
        :param str inbox_id:
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.imap_server_update_flags_with_http_info(imap_update_flags_options, **kwargs)  # noqa: E501

    def imap_server_update_flags_with_http_info(self, imap_update_flags_options, **kwargs):  # noqa: E501
        """imap_server_update_flags  # noqa: E501

        Update message flags  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.imap_server_update_flags_with_http_info(imap_update_flags_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param ImapUpdateFlagsOptions imap_update_flags_options: (required)
        :param str inbox_id:
        :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 = [
            'imap_update_flags_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 imap_server_update_flags" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'imap_update_flags_options' is set
        if self.api_client.client_side_validation and ('imap_update_flags_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['imap_update_flags_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `imap_update_flags_options` when calling `imap_server_update_flags`")  # 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 'imap_update_flags_options' in local_var_params:
            body_params = local_var_params['imap_update_flags_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(
            '/imap/server/update-flags', '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)

mailslurp_client/api/group_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class GroupControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def add_contacts_to_group(self, group_id, update_group_contacts, **kwargs):  # noqa: E501
        """Add contacts to 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.add_contacts_to_group(group_id, update_group_contacts, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str group_id: (required)
        :param UpdateGroupContacts update_group_contacts: (required)
        :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: GroupContactsDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.add_contacts_to_group_with_http_info(group_id, update_group_contacts, **kwargs)  # noqa: E501

    def add_contacts_to_group_with_http_info(self, group_id, update_group_contacts, **kwargs):  # noqa: E501
        """Add contacts to 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.add_contacts_to_group_with_http_info(group_id, update_group_contacts, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str group_id: (required)
        :param UpdateGroupContacts update_group_contacts: (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'
        ]
        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 add_contacts_to_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 `add_contacts_to_group`")  # noqa: E501
        # verify the required parameter 'update_group_contacts' is set
        if self.api_client.client_side_validation and ('update_group_contacts' not in local_var_params or  # noqa: E501
                                                        local_var_params['update_group_contacts'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `update_group_contacts` when calling `add_contacts_to_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' in local_var_params:
            body_params = local_var_params['update_group_contacts']
        # 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(
            '/groups/{groupId}/contacts', 'PUT',
            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_group(self, create_group_options, **kwargs):  # noqa: E501
        """Create 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.create_group(create_group_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateGroupOptions create_group_options: (required)
        :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: GroupDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_group_with_http_info(create_group_options, **kwargs)  # noqa: E501

    def create_group_with_http_info(self, create_group_options, **kwargs):  # noqa: E501
        """Create 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.create_group_with_http_info(create_group_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateGroupOptions create_group_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(GroupDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_group_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_group" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'create_group_options' is set
        if self.api_client.client_side_validation and ('create_group_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_group_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_group_options` when calling `create_group`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_group_options' in local_var_params:
            body_params = local_var_params['create_group_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(
            '/groups', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GroupDto',  # 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_group(self, group_id, **kwargs):  # noqa: E501
        """Delete 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.delete_group(group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str group_id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_group_with_http_info(group_id, **kwargs)  # noqa: E501

    def delete_group_with_http_info(self, group_id, **kwargs):  # noqa: E501
        """Delete 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.delete_group_with_http_info(group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str group_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 = [
            'group_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_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 `delete_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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/groups/{groupId}', '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_all_groups(self, **kwargs):  # noqa: E501
        """Get all Contact Groups in paginated format  # 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_all_groups(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 in list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageGroupProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_all_groups_with_http_info(**kwargs)  # noqa: E501

    def get_all_groups_with_http_info(self, **kwargs):  # noqa: E501
        """Get all Contact Groups in paginated format  # 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_all_groups_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 in list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PageGroupProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            '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 get_all_groups" % 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
        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(
            '/groups/paginated', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageGroupProjection',  # 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(self, group_id, **kwargs):  # noqa: E501
        """Get 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.get_group(group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str group_id: (required)
        :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: GroupDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_group_with_http_info(group_id, **kwargs)  # noqa: E501

    def get_group_with_http_info(self, group_id, **kwargs):  # noqa: E501
        """Get 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.get_group_with_http_info(group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str group_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: tuple(GroupDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'group_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_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 `get_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
        # 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(
            '/groups/{groupId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GroupDto',  # 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(self, group_id, **kwargs):  # noqa: E501
        """Get group and 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(group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str group_id: (required)
        :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: GroupContactsDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_group_with_contacts_with_http_info(group_id, **kwargs)  # noqa: E501

    def get_group_with_contacts_with_http_info(self, group_id, **kwargs):  # noqa: E501
        """Get group and 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_with_http_info(group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str group_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: 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'
        ]
        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" % 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`")  # 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
        # 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(
            '/groups/{groupId}/contacts', 'GET',
            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 get_group_with_contacts_paginated(self, group_id, **kwargs):  # noqa: E501
        """get_group_with_contacts_paginated  # 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(group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str group_id: (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 datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageContactProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_group_with_contacts_paginated_with_http_info(group_id, **kwargs)  # noqa: E501

    def get_group_with_contacts_paginated_with_http_info(self, group_id, **kwargs):  # noqa: E501
        """get_group_with_contacts_paginated  # 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: (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 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(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',
            '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 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
        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(
            '/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 get_groups(self, **kwargs):  # noqa: E501
        """Get all groups  # 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_groups(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: list[GroupProjection]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_groups_with_http_info(**kwargs)  # noqa: E501

    def get_groups_with_http_info(self, **kwargs):  # noqa: E501
        """Get all groups  # 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_groups_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(list[GroupProjection], 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_groups" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/groups', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[GroupProjection]',  # 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(self, group_id, update_group_contacts, **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(group_id, update_group_contacts, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str group_id: (required)
        :param UpdateGroupContacts update_group_contacts: (required)
        :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: GroupContactsDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.remove_contacts_from_group_with_http_info(group_id, update_group_contacts, **kwargs)  # noqa: E501

    def remove_contacts_from_group_with_http_info(self, group_id, update_group_contacts, **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, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str group_id: (required)
        :param UpdateGroupContacts update_group_contacts: (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'
        ]
        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' is set
        if self.api_client.client_side_validation and ('update_group_contacts' not in local_var_params or  # noqa: E501
                                                        local_var_params['update_group_contacts'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `update_group_contacts` 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' in local_var_params:
            body_params = local_var_params['update_group_contacts']
        # 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(
            '/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)

mailslurp_client/api/form_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class FormControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def submit_form(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 `?_to=test@example.com`  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://python.api.mailslurp.com/forms\"   method=\"post\" >   <input name=\"_to\" type=\"hidden\" value=\"test@example.com\"/>   <textarea name=\"feedback\"></textarea>   <button type=\"submit\">Submit</button> </form> ```  #### URL Example ```html <form    action=\"https://python.api.mailslurp.com/forms?_to=test@example.com\"   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(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str to: The email address that submitted form should be sent to.
        :param str subject: Optional subject of the email that will be sent.
        :param str redirect_to: Optional URL to redirect form submitter to after submission. If not present user will see a success message.
        :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 success_message: Optional success message to display if no _redirectTo present.
        :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 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 _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: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.submit_form_with_http_info(**kwargs)  # noqa: E501

    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 `?_to=test@example.com`  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://python.api.mailslurp.com/forms\"   method=\"post\" >   <input name=\"_to\" type=\"hidden\" value=\"test@example.com\"/>   <textarea name=\"feedback\"></textarea>   <button type=\"submit\">Submit</button> </form> ```  #### URL Example ```html <form    action=\"https://python.api.mailslurp.com/forms?_to=test@example.com\"   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 to: The email address that submitted form should be sent to.
        :param str subject: Optional subject of the email that will be sent.
        :param str redirect_to: Optional URL to redirect form submitter to after submission. If not present user will see a success message.
        :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 success_message: Optional success message to display if no _redirectTo present.
        :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 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 = [
            'to',
            'subject',
            'redirect_to',
            'email_address',
            'success_message',
            'spam_check',
            '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 = []
        if 'to' in local_var_params and local_var_params['to'] is not None:  # noqa: E501
            query_params.append(('_to', local_var_params['to']))  # noqa: E501
        if 'subject' in local_var_params and local_var_params['subject'] is not None:  # noqa: E501
            query_params.append(('_subject', local_var_params['subject']))  # noqa: E501
        if 'redirect_to' in local_var_params and local_var_params['redirect_to'] is not None:  # noqa: E501
            query_params.append(('_redirectTo', local_var_params['redirect_to']))  # noqa: E501
        if 'email_address' in local_var_params and local_var_params['email_address'] is not None:  # noqa: E501
            query_params.append(('_emailAddress', local_var_params['email_address']))  # noqa: E501
        if 'success_message' in local_var_params and local_var_params['success_message'] is not None:  # noqa: E501
            query_params.append(('_successMessage', local_var_params['success_message']))  # noqa: E501
        if 'spam_check' in local_var_params and local_var_params['spam_check'] is not None:  # noqa: E501
            query_params.append(('_spamCheck', local_var_params['spam_check']))  # noqa: E501
        if 'other_parameters' in local_var_params and local_var_params['other_parameters'] is not None:  # noqa: E501
            query_params.append(('otherParameters', local_var_params['other_parameters']))  # 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(
            '/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)

mailslurp_client/api/export_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class ExportControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def export_entities(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(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 _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: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.export_entities_with_http_info(export_type, api_key, output_format, **kwargs)  # noqa: E501

    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(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='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_export_link(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(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 _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: ExportLink
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_export_link_with_http_info(export_type, export_options, **kwargs)  # noqa: E501

    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)

mailslurp_client/api/expired_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class ExpiredControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def get_expiration_defaults(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(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: ExpirationDefaults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_expiration_defaults_with_http_info(**kwargs)  # noqa: E501

    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(
            ['*/*'])  # 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 get_expired_inbox_by_inbox_id(self, inbox_id, **kwargs):  # noqa: E501
        """Get expired inbox record for a previously existing inbox  # noqa: E501

        Use the inboxId to return an ExpiredInboxRecord if an inbox has expired. Inboxes expire and are disabled if an expiration date is set or plan requires. Returns 404 if no expired inbox is found for the inboxId  # 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_by_inbox_id(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox you want to retrieve (not the inbox ID) (required)
        :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: ExpiredInboxDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_expired_inbox_by_inbox_id_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def get_expired_inbox_by_inbox_id_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """Get expired inbox record for a previously existing inbox  # noqa: E501

        Use the inboxId to return an ExpiredInboxRecord if an inbox has expired. Inboxes expire and are disabled if an expiration date is set or plan requires. Returns 404 if no expired inbox is found for the inboxId  # 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_by_inbox_id_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox you want to retrieve (not the inbox 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: tuple(ExpiredInboxDto, status_code(int), headers(HTTPHeaderDict))
                 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 get_expired_inbox_by_inbox_id" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `get_expired_inbox_by_inbox_id`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/expired/inbox/{inboxId}', '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_expired_inbox_record(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(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 _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: ExpiredInboxDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_expired_inbox_record_with_http_info(expired_id, **kwargs)  # noqa: E501

    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(
            ['*/*'])  # 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_expired_inboxes(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(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 datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageExpiredInboxRecordProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_expired_inboxes_with_http_info(**kwargs)  # noqa: E501

    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 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(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',
            '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 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
        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(
            '/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)

mailslurp_client/api/email_verification_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class EmailVerificationControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def delete_all_validation_requests(self, **kwargs):  # noqa: E501
        """Delete all validation requests  # 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_all_validation_requests(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_all_validation_requests_with_http_info(**kwargs)  # noqa: E501

    def delete_all_validation_requests_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all validation requests  # 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_all_validation_requests_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: None
                 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 delete_all_validation_requests" % 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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/email-verification', '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 delete_validation_request(self, id, **kwargs):  # noqa: E501
        """Delete a validation record  # 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_validation_request(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_validation_request_with_http_info(id, **kwargs)  # noqa: E501

    def delete_validation_request_with_http_info(self, id, **kwargs):  # noqa: E501
        """Delete a validation record  # 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_validation_request_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str 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 = [
            '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_validation_request" % 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 `delete_validation_request`")  # 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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/email-verification/{id}', '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_validation_requests(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(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 _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: PageEmailValidationRequest
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_validation_requests_with_http_info(**kwargs)  # noqa: E501

    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 validate_email_address_list(self, validate_email_address_list_options, **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.validate_email_address_list(validate_email_address_list_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param ValidateEmailAddressListOptions validate_email_address_list_options: (required)
        :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: ValidateEmailAddressListResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.validate_email_address_list_with_http_info(validate_email_address_list_options, **kwargs)  # noqa: E501

    def validate_email_address_list_with_http_info(self, validate_email_address_list_options, **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.validate_email_address_list_with_http_info(validate_email_address_list_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param ValidateEmailAddressListOptions validate_email_address_list_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(ValidateEmailAddressListResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'validate_email_address_list_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 validate_email_address_list" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'validate_email_address_list_options' is set
        if self.api_client.client_side_validation and ('validate_email_address_list_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['validate_email_address_list_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `validate_email_address_list_options` when calling `validate_email_address_list`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'validate_email_address_list_options' in local_var_params:
            body_params = local_var_params['validate_email_address_list_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(
            '/email-verification/email-address-list', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ValidateEmailAddressListResult',  # 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)

mailslurp_client/api/email_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class EmailControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def apply_imap_flag_operation(self, email_id, imap_flag_operation_options, **kwargs):  # noqa: E501
        """Set IMAP flags associated with a message. Only supports '\\Seen' flag.  # noqa: E501

        Apply RFC3501 section-2.3.2 IMAP flag operations on an 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.apply_imap_flag_operation(email_id, imap_flag_operation_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param ImapFlagOperationOptions imap_flag_operation_options: (required)
        :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: EmailPreview
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.apply_imap_flag_operation_with_http_info(email_id, imap_flag_operation_options, **kwargs)  # noqa: E501

    def apply_imap_flag_operation_with_http_info(self, email_id, imap_flag_operation_options, **kwargs):  # noqa: E501
        """Set IMAP flags associated with a message. Only supports '\\Seen' flag.  # noqa: E501

        Apply RFC3501 section-2.3.2 IMAP flag operations on an 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.apply_imap_flag_operation_with_http_info(email_id, imap_flag_operation_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param ImapFlagOperationOptions imap_flag_operation_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(EmailPreview, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'imap_flag_operation_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 apply_imap_flag_operation" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `apply_imap_flag_operation`")  # noqa: E501
        # verify the required parameter 'imap_flag_operation_options' is set
        if self.api_client.client_side_validation and ('imap_flag_operation_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['imap_flag_operation_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `imap_flag_operation_options` when calling `apply_imap_flag_operation`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'imap_flag_operation_options' in local_var_params:
            body_params = local_var_params['imap_flag_operation_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(
            '/emails/{emailId}/imap-flag-operation', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='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 can_send(self, inbox_id, send_email_options, **kwargs):  # noqa: E501
        """Check if email can be sent and options are valid.  # noqa: E501

        Can user send email to given recipient or is the recipient blocked  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.can_send(inbox_id, send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of the inbox you want to send the email from (required)
        :param SendEmailOptions send_email_options: (required)
        :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: CanSendEmailResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.can_send_with_http_info(inbox_id, send_email_options, **kwargs)  # noqa: E501

    def can_send_with_http_info(self, inbox_id, send_email_options, **kwargs):  # noqa: E501
        """Check if email can be sent and options are valid.  # noqa: E501

        Can user send email to given recipient or is the recipient blocked  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.can_send_with_http_info(inbox_id, send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of the inbox you want to send the email from (required)
        :param SendEmailOptions send_email_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(CanSendEmailResults, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            '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 can_send" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `can_send`")  # noqa: E501
        # verify the required parameter 'send_email_options' is set
        if self.api_client.client_side_validation and ('send_email_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['send_email_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `send_email_options` when calling `can_send`")  # 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 'send_email_options' in local_var_params:
            body_params = local_var_params['send_email_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(
            '/emails/can-send', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CanSendEmailResults',  # 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 check_email_body(self, email_id, **kwargs):  # noqa: E501
        """Detect broken links, spelling, and images in email content  # noqa: E501

        Find dead links, broken images, and spelling mistakes in email body. Will call included links via HTTP so do not invoke if your links are sensitive or stateful. Any resource that returns a 4xx or 5xx response or is not reachable via HEAD or GET HTTP operations will be considered unhealthy.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.check_email_body(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :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: CheckEmailBodyResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.check_email_body_with_http_info(email_id, **kwargs)  # noqa: E501

    def check_email_body_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Detect broken links, spelling, and images in email content  # noqa: E501

        Find dead links, broken images, and spelling mistakes in email body. Will call included links via HTTP so do not invoke if your links are sensitive or stateful. Any resource that returns a 4xx or 5xx response or is not reachable via HEAD or GET HTTP operations will be considered unhealthy.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.check_email_body_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_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: tuple(CheckEmailBodyResults, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_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 check_email_body" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `check_email_body`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/emails/{emailId}/check-email-body', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CheckEmailBodyResults',  # 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 check_email_body_feature_support(self, email_id, **kwargs):  # noqa: E501
        """Show which mail clients support the HTML and CSS features used in an email body.  # noqa: E501

        Detect HTML and CSS features inside an email body and return a report of email client support across different platforms and versions.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.check_email_body_feature_support(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :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: CheckEmailBodyFeatureSupportResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.check_email_body_feature_support_with_http_info(email_id, **kwargs)  # noqa: E501

    def check_email_body_feature_support_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Show which mail clients support the HTML and CSS features used in an email body.  # noqa: E501

        Detect HTML and CSS features inside an email body and return a report of email client support across different platforms and versions.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.check_email_body_feature_support_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_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: tuple(CheckEmailBodyFeatureSupportResults, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_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 check_email_body_feature_support" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `check_email_body_feature_support`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/emails/{emailId}/check-email-body-feature-support', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CheckEmailBodyFeatureSupportResults',  # 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 check_email_client_support(self, check_email_client_support_options, **kwargs):  # noqa: E501
        """Show which email programs and devices support the features used in an email body.  # noqa: E501

        Evaluate the features used in an email body and return a report of email client support across different platforms and versions.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.check_email_client_support(check_email_client_support_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CheckEmailClientSupportOptions check_email_client_support_options: (required)
        :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: CheckEmailClientSupportResults
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.check_email_client_support_with_http_info(check_email_client_support_options, **kwargs)  # noqa: E501

    def check_email_client_support_with_http_info(self, check_email_client_support_options, **kwargs):  # noqa: E501
        """Show which email programs and devices support the features used in an email body.  # noqa: E501

        Evaluate the features used in an email body and return a report of email client support across different platforms and versions.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.check_email_client_support_with_http_info(check_email_client_support_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CheckEmailClientSupportOptions check_email_client_support_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(CheckEmailClientSupportResults, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'check_email_client_support_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 check_email_client_support" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'check_email_client_support_options' is set
        if self.api_client.client_side_validation and ('check_email_client_support_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['check_email_client_support_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `check_email_client_support_options` when calling `check_email_client_support`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'check_email_client_support_options' in local_var_params:
            body_params = local_var_params['check_email_client_support_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(
            '/emails/check-email-client-support', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CheckEmailClientSupportResults',  # 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_all_emails(self, **kwargs):  # noqa: E501
        """Delete all emails in all inboxes.  # noqa: E501

        Deletes all emails in your account. Be careful as emails cannot be recovered  # 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_all_emails(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_all_emails_with_http_info(**kwargs)  # noqa: E501

    def delete_all_emails_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all emails in all inboxes.  # noqa: E501

        Deletes all emails in your account. Be careful as emails cannot be recovered  # 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_all_emails_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: None
                 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 delete_all_emails" % 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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/emails', '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 delete_email(self, email_id, **kwargs):  # noqa: E501
        """Delete an email  # noqa: E501

        Deletes an email and removes it from the inbox. Deleted emails cannot be recovered.  # 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_email(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to delete (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_email_with_http_info(email_id, **kwargs)  # noqa: E501

    def delete_email_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Delete an email  # noqa: E501

        Deletes an email and removes it from the inbox. Deleted emails cannot be recovered.  # 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_email_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to delete (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 = [
            'email_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_email" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `delete_email`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_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(
            '/emails/{emailId}', '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 download_attachment(self, email_id, attachment_id, **kwargs):  # noqa: E501
        """Get email attachment bytes. Returned as `octet-stream` with content type header. If you have trouble with byte responses try the `downloadAttachmentBase64` response endpoints and convert the base 64 encoded content to a file or string.  # noqa: E501

        Returns the specified attachment for a given email as a stream / array of bytes. You can find attachment ids in email responses endpoint responses. The response type is application/octet-stream.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.download_attachment(email_id, attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (required)
        :param str attachment_id: ID of attachment (required)
        :param str api_key: Can pass apiKey in url for this request if you wish to download the file in a browser. Content type will be set to original content type of the attachment file. This is so that browsers can download the file correctly.
        :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: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.download_attachment_with_http_info(email_id, attachment_id, **kwargs)  # noqa: E501

    def download_attachment_with_http_info(self, email_id, attachment_id, **kwargs):  # noqa: E501
        """Get email attachment bytes. Returned as `octet-stream` with content type header. If you have trouble with byte responses try the `downloadAttachmentBase64` response endpoints and convert the base 64 encoded content to a file or string.  # noqa: E501

        Returns the specified attachment for a given email as a stream / array of bytes. You can find attachment ids in email responses endpoint responses. The response type is application/octet-stream.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.download_attachment_with_http_info(email_id, attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (required)
        :param str attachment_id: ID of attachment (required)
        :param str api_key: Can pass apiKey in url for this request if you wish to download the file in a browser. Content type will be set to original content type of the attachment file. This is so that browsers can download the file correctly.
        :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_id',
            'attachment_id',
            '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 download_attachment" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `download_attachment`")  # noqa: E501
        # verify the required parameter 'attachment_id' is set
        if self.api_client.client_side_validation and ('attachment_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['attachment_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `attachment_id` when calling `download_attachment`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501
        if 'attachment_id' in local_var_params:
            path_params['attachmentId'] = local_var_params['attachment_id']  # noqa: E501

        query_params = []
        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
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/octet-stream'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/emails/{emailId}/attachments/{attachmentId}', 'GET',
            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 download_attachment_base64(self, email_id, attachment_id, **kwargs):  # noqa: E501
        """Get email attachment as base64 encoded string as an alternative to binary responses. Decode the `base64FileContents` as a `utf-8` encoded string or array of bytes depending on the `contentType`.  # noqa: E501

        Returns the specified attachment for a given email as a base 64 encoded string. The response type is application/json. This method is similar to the `downloadAttachment` method but allows some clients to get around issues with binary responses.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.download_attachment_base64(email_id, attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (required)
        :param str attachment_id: ID of attachment (required)
        :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: DownloadAttachmentDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.download_attachment_base64_with_http_info(email_id, attachment_id, **kwargs)  # noqa: E501

    def download_attachment_base64_with_http_info(self, email_id, attachment_id, **kwargs):  # noqa: E501
        """Get email attachment as base64 encoded string as an alternative to binary responses. Decode the `base64FileContents` as a `utf-8` encoded string or array of bytes depending on the `contentType`.  # noqa: E501

        Returns the specified attachment for a given email as a base 64 encoded string. The response type is application/json. This method is similar to the `downloadAttachment` method but allows some clients to get around issues with binary responses.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.download_attachment_base64_with_http_info(email_id, attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (required)
        :param str attachment_id: ID of attachment (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(DownloadAttachmentDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'attachment_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 download_attachment_base64" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `download_attachment_base64`")  # noqa: E501
        # verify the required parameter 'attachment_id' is set
        if self.api_client.client_side_validation and ('attachment_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['attachment_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `attachment_id` when calling `download_attachment_base64`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501
        if 'attachment_id' in local_var_params:
            path_params['attachmentId'] = local_var_params['attachment_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/emails/{emailId}/attachments/{attachmentId}/base64', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DownloadAttachmentDto',  # 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 download_body(self, email_id, **kwargs):  # noqa: E501
        """Get email body as string. Returned as `plain/text` with content type header.  # noqa: E501

        Returns the specified email body for a given email as a string  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.download_body(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (required)
        :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: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.download_body_with_http_info(email_id, **kwargs)  # noqa: E501

    def download_body_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Get email body as string. Returned as `plain/text` with content type header.  # noqa: E501

        Returns the specified email body for a given email as a string  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.download_body_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (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(str, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_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 download_body" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `download_body`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_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(
            ['text/plain', 'text/html'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/emails/{emailId}/body', 'GET',
            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 download_body_bytes(self, email_id, **kwargs):  # noqa: E501
        """Get email body in bytes. Returned as `octet-stream` with content type header.  # noqa: E501

        Returns the specified email body for a given email as a stream / array of bytes.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.download_body_bytes(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (required)
        :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: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.download_body_bytes_with_http_info(email_id, **kwargs)  # noqa: E501

    def download_body_bytes_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Get email body in bytes. Returned as `octet-stream` with content type header.  # noqa: E501

        Returns the specified email body for a given email as a stream / array of bytes.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.download_body_bytes_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (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(str, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_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 download_body_bytes" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `download_body_bytes`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_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/octet-stream'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/emails/{emailId}/body-bytes', 'GET',
            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 forward_email(self, email_id, forward_email_options, **kwargs):  # noqa: E501
        """Forward email to recipients  # noqa: E501

        Forward an existing email to new recipients. The sender of the email will be the inbox that received the email you are forwarding. You can override the sender with the `from` option. Note you must have access to the from address in MailSlurp to use the override. For more control consider fetching the email and sending it a new using the send email endpoints.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.forward_email(email_id, forward_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (required)
        :param ForwardEmailOptions forward_email_options: (required)
        :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: SentEmailDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.forward_email_with_http_info(email_id, forward_email_options, **kwargs)  # noqa: E501

    def forward_email_with_http_info(self, email_id, forward_email_options, **kwargs):  # noqa: E501
        """Forward email to recipients  # noqa: E501

        Forward an existing email to new recipients. The sender of the email will be the inbox that received the email you are forwarding. You can override the sender with the `from` option. Note you must have access to the from address in MailSlurp to use the override. For more control consider fetching the email and sending it a new using the send email endpoints.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.forward_email_with_http_info(email_id, forward_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (required)
        :param ForwardEmailOptions forward_email_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(SentEmailDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'forward_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 forward_email" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `forward_email`")  # noqa: E501
        # verify the required parameter 'forward_email_options' is set
        if self.api_client.client_side_validation and ('forward_email_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['forward_email_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `forward_email_options` when calling `forward_email`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'forward_email_options' in local_var_params:
            body_params = local_var_params['forward_email_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(
            '/emails/{emailId}/forward', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SentEmailDto',  # 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_attachment_meta_data(self, email_id, attachment_id, **kwargs):  # noqa: E501
        """Get email attachment metadata. This is the `contentType` and `contentLength` of an attachment. To get the individual attachments  use the `downloadAttachment` methods.  # noqa: E501

        Returns the metadata such as name and content-type for a given attachment and 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.get_attachment_meta_data(email_id, attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (required)
        :param str attachment_id: ID of attachment (required)
        :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: AttachmentMetaData
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_attachment_meta_data_with_http_info(email_id, attachment_id, **kwargs)  # noqa: E501

    def get_attachment_meta_data_with_http_info(self, email_id, attachment_id, **kwargs):  # noqa: E501
        """Get email attachment metadata. This is the `contentType` and `contentLength` of an attachment. To get the individual attachments  use the `downloadAttachment` methods.  # noqa: E501

        Returns the metadata such as name and content-type for a given attachment and 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.get_attachment_meta_data_with_http_info(email_id, attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (required)
        :param str attachment_id: ID of attachment (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(AttachmentMetaData, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'attachment_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_attachment_meta_data" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_attachment_meta_data`")  # noqa: E501
        # verify the required parameter 'attachment_id' is set
        if self.api_client.client_side_validation and ('attachment_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['attachment_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `attachment_id` when calling `get_attachment_meta_data`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501
        if 'attachment_id' in local_var_params:
            path_params['attachmentId'] = local_var_params['attachment_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/emails/{emailId}/attachments/{attachmentId}/metadata', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AttachmentMetaData',  # 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_email(self, email_id, **kwargs):  # noqa: E501
        """Get email content including headers and body. Expects email to exist by ID. For emails that may not have arrived yet use the WaitForController.  # noqa: E501

        Returns a email summary object with headers and content. To retrieve the raw unparsed email use the getRawEmail endpoints  # 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_email(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param bool decode: Decode email body quoted-printable encoding to plain text. SMTP servers often encode text using quoted-printable format (for instance `=D7`). This can be a pain for testing
        :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: Email
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_email_with_http_info(email_id, **kwargs)  # noqa: E501

    def get_email_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Get email content including headers and body. Expects email to exist by ID. For emails that may not have arrived yet use the WaitForController.  # noqa: E501

        Returns a email summary object with headers and content. To retrieve the raw unparsed email use the getRawEmail endpoints  # 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_email_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param bool decode: Decode email body quoted-printable encoding to plain text. SMTP servers often encode text using quoted-printable format (for instance `=D7`). This can be a pain for testing
        :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 = [
            'email_id',
            'decode'
        ]
        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_email" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_email`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []
        if 'decode' in local_var_params and local_var_params['decode'] is not None:  # noqa: E501
            query_params.append(('decode', local_var_params['decode']))  # 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(
            '/emails/{emailId}', '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_email_attachments(self, email_id, **kwargs):  # noqa: E501
        """Get all email attachment metadata. Metadata includes name and size of attachments.  # noqa: E501

        Returns an array of attachment metadata such as name and content-type for a given email if present.  # 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_email_attachments(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (required)
        :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: list[AttachmentMetaData]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_email_attachments_with_http_info(email_id, **kwargs)  # noqa: E501

    def get_email_attachments_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Get all email attachment metadata. Metadata includes name and size of attachments.  # noqa: E501

        Returns an array of attachment metadata such as name and content-type for a given email if present.  # 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_email_attachments_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (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[AttachmentMetaData], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_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_email_attachments" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_email_attachments`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/emails/{emailId}/attachments', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[AttachmentMetaData]',  # 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_email_content_match(self, email_id, content_match_options, **kwargs):  # noqa: E501
        """Get email content regex pattern match results. Runs regex against email body and returns match groups.  # noqa: E501

        Return the matches for a given Java style regex pattern. Do not include the typical `/` at start or end of regex in some languages. Given an example `your code is: 12345` the pattern to extract match looks like `code is: (\\d{6})`. This will return an array of matches with the first matching the entire pattern and the subsequent matching the groups: `['code is: 123456', '123456']` See https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html for more information of available patterns.   # 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_email_content_match(email_id, content_match_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to match against (required)
        :param ContentMatchOptions content_match_options: (required)
        :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: EmailContentMatchResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_email_content_match_with_http_info(email_id, content_match_options, **kwargs)  # noqa: E501

    def get_email_content_match_with_http_info(self, email_id, content_match_options, **kwargs):  # noqa: E501
        """Get email content regex pattern match results. Runs regex against email body and returns match groups.  # noqa: E501

        Return the matches for a given Java style regex pattern. Do not include the typical `/` at start or end of regex in some languages. Given an example `your code is: 12345` the pattern to extract match looks like `code is: (\\d{6})`. This will return an array of matches with the first matching the entire pattern and the subsequent matching the groups: `['code is: 123456', '123456']` See https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html for more information of available patterns.   # 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_email_content_match_with_http_info(email_id, content_match_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to match against (required)
        :param ContentMatchOptions content_match_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(EmailContentMatchResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'content_match_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 get_email_content_match" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_email_content_match`")  # noqa: E501
        # verify the required parameter 'content_match_options' is set
        if self.api_client.client_side_validation and ('content_match_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['content_match_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `content_match_options` when calling `get_email_content_match`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'content_match_options' in local_var_params:
            body_params = local_var_params['content_match_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(
            '/emails/{emailId}/contentMatch', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmailContentMatchResult',  # 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_email_content_part(self, email_id, content_type, **kwargs):  # noqa: E501
        """Get email content part by content type  # noqa: E501

        Get email body content parts from a multipart email message for a given content type  # 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_email_content_part(email_id, content_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to match against (required)
        :param str content_type: Content type (required)
        :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: EmailContentPartResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_email_content_part_with_http_info(email_id, content_type, **kwargs)  # noqa: E501

    def get_email_content_part_with_http_info(self, email_id, content_type, **kwargs):  # noqa: E501
        """Get email content part by content type  # noqa: E501

        Get email body content parts from a multipart email message for a given content type  # 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_email_content_part_with_http_info(email_id, content_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to match against (required)
        :param str content_type: Content type (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(EmailContentPartResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'content_type'
        ]
        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_email_content_part" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_email_content_part`")  # noqa: E501
        # verify the required parameter 'content_type' is set
        if self.api_client.client_side_validation and ('content_type' not in local_var_params or  # noqa: E501
                                                        local_var_params['content_type'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `content_type` when calling `get_email_content_part`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []
        if 'content_type' in local_var_params and local_var_params['content_type'] is not None:  # noqa: E501
            query_params.append(('contentType', local_var_params['content_type']))  # 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(
            '/emails/{emailId}/contentPart', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmailContentPartResult',  # 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_email_count(self, **kwargs):  # noqa: E501
        """Get email count  # 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_email_count(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id:
        :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: CountDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_email_count_with_http_info(**kwargs)  # noqa: E501

    def get_email_count_with_http_info(self, **kwargs):  # noqa: E501
        """Get email count  # 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_email_count_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id:
        :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(CountDto, status_code(int), headers(HTTPHeaderDict))
                 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 get_email_count" % 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
        # 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(
            '/emails/emails/count', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CountDto',  # 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_email_html(self, email_id, **kwargs):  # noqa: E501
        """Get email content as HTML. For displaying emails in browser context.  # noqa: E501

        Retrieve email content as HTML response for viewing in browsers. Decodes quoted-printable entities and converts charset to UTF-8. Pass your API KEY as a request parameter when viewing in a browser: `?apiKey=xxx`. Returns content-type `text/html;charset=utf-8` so you must call expecting that content response not JSON. For JSON response see the `getEmailHTMLJson` 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.get_email_html(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param bool decode:
        :param bool replace_cid_images:
        :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: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_email_html_with_http_info(email_id, **kwargs)  # noqa: E501

    def get_email_html_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Get email content as HTML. For displaying emails in browser context.  # noqa: E501

        Retrieve email content as HTML response for viewing in browsers. Decodes quoted-printable entities and converts charset to UTF-8. Pass your API KEY as a request parameter when viewing in a browser: `?apiKey=xxx`. Returns content-type `text/html;charset=utf-8` so you must call expecting that content response not JSON. For JSON response see the `getEmailHTMLJson` 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.get_email_html_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param bool decode:
        :param bool replace_cid_images:
        :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_id',
            'decode',
            'replace_cid_images'
        ]
        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_email_html" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_email_html`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []
        if 'decode' in local_var_params and local_var_params['decode'] is not None:  # noqa: E501
            query_params.append(('decode', local_var_params['decode']))  # noqa: E501
        if 'replace_cid_images' in local_var_params and local_var_params['replace_cid_images'] is not None:  # noqa: E501
            query_params.append(('replaceCidImages', local_var_params['replace_cid_images']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['text/html;charset=utf-8', 'text/html'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/emails/{emailId}/html', 'GET',
            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_email_html_json(self, email_id, **kwargs):  # noqa: E501
        """Get email content as HTML in JSON wrapper. For fetching entity decoded HTML content  # noqa: E501

        Retrieve email content as HTML response. Decodes quoted-printable entities and converts charset to UTF-8. Returns content-type `application/json;charset=utf-8` so you must call expecting that content response not JSON.  # 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_email_html_json(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param bool decode:
        :param bool replace_cid_images:
        :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: EmailHtmlDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_email_html_json_with_http_info(email_id, **kwargs)  # noqa: E501

    def get_email_html_json_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Get email content as HTML in JSON wrapper. For fetching entity decoded HTML content  # noqa: E501

        Retrieve email content as HTML response. Decodes quoted-printable entities and converts charset to UTF-8. Returns content-type `application/json;charset=utf-8` so you must call expecting that content response not JSON.  # 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_email_html_json_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param bool decode:
        :param bool replace_cid_images:
        :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(EmailHtmlDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'decode',
            'replace_cid_images'
        ]
        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_email_html_json" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_email_html_json`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []
        if 'decode' in local_var_params and local_var_params['decode'] is not None:  # noqa: E501
            query_params.append(('decode', local_var_params['decode']))  # noqa: E501
        if 'replace_cid_images' in local_var_params and local_var_params['replace_cid_images'] is not None:  # noqa: E501
            query_params.append(('replaceCidImages', local_var_params['replace_cid_images']))  # 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(
            '/emails/{emailId}/html/json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmailHtmlDto',  # 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_email_html_query(self, email_id, html_selector, **kwargs):  # noqa: E501
        """Parse and return text from an email, stripping HTML and decoding encoded characters  # noqa: E501

        Parse an email body and return the content as an array of text. HTML parsing uses JSoup which supports JQuery/CSS style selectors  # 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_email_html_query(email_id, html_selector, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to perform HTML query on (required)
        :param str html_selector: HTML selector to search for. Uses JQuery/JSoup/CSS style selector like '.my-div' to match content. See https://jsoup.org/apidocs/org/jsoup/select/Selector.html for more information. (required)
        :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: EmailTextLinesResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_email_html_query_with_http_info(email_id, html_selector, **kwargs)  # noqa: E501

    def get_email_html_query_with_http_info(self, email_id, html_selector, **kwargs):  # noqa: E501
        """Parse and return text from an email, stripping HTML and decoding encoded characters  # noqa: E501

        Parse an email body and return the content as an array of text. HTML parsing uses JSoup which supports JQuery/CSS style selectors  # 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_email_html_query_with_http_info(email_id, html_selector, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to perform HTML query on (required)
        :param str html_selector: HTML selector to search for. Uses JQuery/JSoup/CSS style selector like '.my-div' to match content. See https://jsoup.org/apidocs/org/jsoup/select/Selector.html for more information. (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(EmailTextLinesResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'html_selector'
        ]
        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_email_html_query" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_email_html_query`")  # noqa: E501
        # verify the required parameter 'html_selector' is set
        if self.api_client.client_side_validation and ('html_selector' not in local_var_params or  # noqa: E501
                                                        local_var_params['html_selector'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `html_selector` when calling `get_email_html_query`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []
        if 'html_selector' in local_var_params and local_var_params['html_selector'] is not None:  # noqa: E501
            query_params.append(('htmlSelector', local_var_params['html_selector']))  # 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(
            '/emails/{emailId}/htmlQuery', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmailTextLinesResult',  # 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_email_links(self, email_id, **kwargs):  # noqa: E501
        """Parse and return list of links found in an email (only works for HTML content)  # noqa: E501

        HTML parsing uses JSoup and UNIX line separators. Searches content for href attributes  # 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_email_links(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to fetch text for (required)
        :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: EmailLinksResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_email_links_with_http_info(email_id, **kwargs)  # noqa: E501

    def get_email_links_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Parse and return list of links found in an email (only works for HTML content)  # noqa: E501

        HTML parsing uses JSoup and UNIX line separators. Searches content for href attributes  # 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_email_links_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to fetch text for (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(EmailLinksResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_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_email_links" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_email_links`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/emails/{emailId}/links', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmailLinksResult',  # 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_email_preview_ur_ls(self, email_id, **kwargs):  # noqa: E501
        """Get email URLs for viewing in browser or downloading  # noqa: E501

        Get a list of URLs for email content as text/html or raw SMTP message for viewing the message in a 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.get_email_preview_ur_ls(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :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: EmailPreviewUrls
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_email_preview_ur_ls_with_http_info(email_id, **kwargs)  # noqa: E501

    def get_email_preview_ur_ls_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Get email URLs for viewing in browser or downloading  # noqa: E501

        Get a list of URLs for email content as text/html or raw SMTP message for viewing the message in a 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.get_email_preview_ur_ls_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_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: tuple(EmailPreviewUrls, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_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_email_preview_ur_ls" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_email_preview_ur_ls`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/emails/{emailId}/urls', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmailPreviewUrls',  # 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_email_screenshot_as_base64(self, email_id, get_email_screenshot_options, **kwargs):  # noqa: E501
        """Take a screenshot of an email in a browser and return base64 encoded string  # noqa: E501

        Capture image of email screenshot and return as base64 encoded string. Useful for embedding in HTML. Be careful as this may contain sensitive information.  # 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_email_screenshot_as_base64(email_id, get_email_screenshot_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param GetEmailScreenshotOptions get_email_screenshot_options: (required)
        :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: EmailScreenshotResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_email_screenshot_as_base64_with_http_info(email_id, get_email_screenshot_options, **kwargs)  # noqa: E501

    def get_email_screenshot_as_base64_with_http_info(self, email_id, get_email_screenshot_options, **kwargs):  # noqa: E501
        """Take a screenshot of an email in a browser and return base64 encoded string  # noqa: E501

        Capture image of email screenshot and return as base64 encoded string. Useful for embedding in HTML. Be careful as this may contain sensitive information.  # 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_email_screenshot_as_base64_with_http_info(email_id, get_email_screenshot_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param GetEmailScreenshotOptions get_email_screenshot_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(EmailScreenshotResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'get_email_screenshot_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 get_email_screenshot_as_base64" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_email_screenshot_as_base64`")  # noqa: E501
        # verify the required parameter 'get_email_screenshot_options' is set
        if self.api_client.client_side_validation and ('get_email_screenshot_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['get_email_screenshot_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `get_email_screenshot_options` when calling `get_email_screenshot_as_base64`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'get_email_screenshot_options' in local_var_params:
            body_params = local_var_params['get_email_screenshot_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(
            '/emails/{emailId}/screenshot/base64', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmailScreenshotResult',  # 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_email_screenshot_as_binary(self, email_id, get_email_screenshot_options, **kwargs):  # noqa: E501
        """Take a screenshot of an email in a browser  # noqa: E501

        Returns binary octet-stream of screenshot of the given 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.get_email_screenshot_as_binary(email_id, get_email_screenshot_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param GetEmailScreenshotOptions get_email_screenshot_options: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_email_screenshot_as_binary_with_http_info(email_id, get_email_screenshot_options, **kwargs)  # noqa: E501

    def get_email_screenshot_as_binary_with_http_info(self, email_id, get_email_screenshot_options, **kwargs):  # noqa: E501
        """Take a screenshot of an email in a browser  # noqa: E501

        Returns binary octet-stream of screenshot of the given 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.get_email_screenshot_as_binary_with_http_info(email_id, get_email_screenshot_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param GetEmailScreenshotOptions get_email_screenshot_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: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'get_email_screenshot_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 get_email_screenshot_as_binary" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_email_screenshot_as_binary`")  # noqa: E501
        # verify the required parameter 'get_email_screenshot_options' is set
        if self.api_client.client_side_validation and ('get_email_screenshot_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['get_email_screenshot_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `get_email_screenshot_options` when calling `get_email_screenshot_as_binary`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'get_email_screenshot_options' in local_var_params:
            body_params = local_var_params['get_email_screenshot_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(
            '/emails/{emailId}/screenshot/binary', '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 get_email_text_lines(self, email_id, **kwargs):  # noqa: E501
        """Parse and return text from an email, stripping HTML and decoding encoded characters  # noqa: E501

        Parse an email body and return the content as an array of strings. HTML parsing uses JSoup and UNIX line separators.  # 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_email_text_lines(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to fetch text for (required)
        :param bool decode_html_entities: Decode HTML entities
        :param str line_separator: Line separator character
        :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: EmailTextLinesResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_email_text_lines_with_http_info(email_id, **kwargs)  # noqa: E501

    def get_email_text_lines_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Parse and return text from an email, stripping HTML and decoding encoded characters  # noqa: E501

        Parse an email body and return the content as an array of strings. HTML parsing uses JSoup and UNIX line separators.  # 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_email_text_lines_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to fetch text for (required)
        :param bool decode_html_entities: Decode HTML entities
        :param str line_separator: Line separator character
        :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(EmailTextLinesResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'decode_html_entities',
            'line_separator'
        ]
        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_email_text_lines" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_email_text_lines`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []
        if 'decode_html_entities' in local_var_params and local_var_params['decode_html_entities'] is not None:  # noqa: E501
            query_params.append(('decodeHtmlEntities', local_var_params['decode_html_entities']))  # noqa: E501
        if 'line_separator' in local_var_params and local_var_params['line_separator'] is not None:  # noqa: E501
            query_params.append(('lineSeparator', local_var_params['line_separator']))  # 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(
            '/emails/{emailId}/textLines', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmailTextLinesResult',  # 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_emails_offset_paginated(self, **kwargs):  # noqa: E501
        """Get all emails in all inboxes in paginated form. Email API list all.  # noqa: E501

        By default returns all emails across all inboxes sorted by ascending created at date. Responses are paginated. You can restrict results to a list of inbox IDs. You can also filter out read messages  # 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_emails_offset_paginated(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param list[str] inbox_id: Optional inbox ids to filter by. Can be repeated. By default will use all inboxes belonging to your account.
        :param int page: Optional page index in email list pagination
        :param int size: Optional page size in email list pagination. Maximum size is 100. Use page index and sort to page through larger results
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param bool unread_only: Optional filter for unread emails only. All emails are considered unread until they are viewed in the dashboard or requested directly
        :param str search_filter: Optional search filter. Searches email recipients, sender, subject, email address and ID. Does not search email body
        :param datetime since: Optional filter emails received after given date time
        :param datetime before: Optional filter emails received before given date time
        :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: PageEmailProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_emails_offset_paginated_with_http_info(**kwargs)  # noqa: E501

    def get_emails_offset_paginated_with_http_info(self, **kwargs):  # noqa: E501
        """Get all emails in all inboxes in paginated form. Email API list all.  # noqa: E501

        By default returns all emails across all inboxes sorted by ascending created at date. Responses are paginated. You can restrict results to a list of inbox IDs. You can also filter out read messages  # 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_emails_offset_paginated_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param list[str] inbox_id: Optional inbox ids to filter by. Can be repeated. By default will use all inboxes belonging to your account.
        :param int page: Optional page index in email list pagination
        :param int size: Optional page size in email list pagination. Maximum size is 100. Use page index and sort to page through larger results
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param bool unread_only: Optional filter for unread emails only. All emails are considered unread until they are viewed in the dashboard or requested directly
        :param str search_filter: Optional search filter. Searches email recipients, sender, subject, email address and ID. Does not search email body
        :param datetime since: Optional filter emails received after given date time
        :param datetime before: Optional filter emails received before given date 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(PageEmailProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort',
            'unread_only',
            'search_filter',
            '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 get_emails_offset_paginated" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        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_emails_offset_paginated`, must be a value less than or equal to `100`")  # 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
            collection_formats['inboxId'] = 'multi'  # 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 '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 '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
        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

        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(
            '/emails/offset-paginated', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageEmailProjection',  # 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_emails_paginated(self, **kwargs):  # noqa: E501
        """Get all emails in all inboxes in paginated form. Email API list all.  # noqa: E501

        By default returns all emails across all inboxes sorted by ascending created at date. Responses are paginated. You can restrict results to a list of inbox IDs. You can also filter out read messages  # 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_emails_paginated(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param list[str] inbox_id: Optional inbox ids to filter by. Can be repeated. By default will use all inboxes belonging to your account.
        :param int page: Optional page index in email list pagination
        :param int size: Optional page size in email list pagination. Maximum size is 100. Use page index and sort to page through larger results
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param bool unread_only: Optional filter for unread emails only. All emails are considered unread until they are viewed in the dashboard or requested directly
        :param str search_filter: Optional search filter. Searches email recipients, sender, subject, email address and ID. Does not search email body
        :param datetime since: Optional filter emails received after given date time. If unset will use time 24hours prior to now.
        :param datetime before: Optional filter emails received before given date time
        :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: PageEmailProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_emails_paginated_with_http_info(**kwargs)  # noqa: E501

    def get_emails_paginated_with_http_info(self, **kwargs):  # noqa: E501
        """Get all emails in all inboxes in paginated form. Email API list all.  # noqa: E501

        By default returns all emails across all inboxes sorted by ascending created at date. Responses are paginated. You can restrict results to a list of inbox IDs. You can also filter out read messages  # 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_emails_paginated_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param list[str] inbox_id: Optional inbox ids to filter by. Can be repeated. By default will use all inboxes belonging to your account.
        :param int page: Optional page index in email list pagination
        :param int size: Optional page size in email list pagination. Maximum size is 100. Use page index and sort to page through larger results
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param bool unread_only: Optional filter for unread emails only. All emails are considered unread until they are viewed in the dashboard or requested directly
        :param str search_filter: Optional search filter. Searches email recipients, sender, subject, email address and ID. Does not search email body
        :param datetime since: Optional filter emails received after given date time. If unset will use time 24hours prior to now.
        :param datetime before: Optional filter emails received before given date 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(PageEmailProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort',
            'unread_only',
            'search_filter',
            '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 get_emails_paginated" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        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_emails_paginated`, must be a value less than or equal to `100`")  # 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
            collection_formats['inboxId'] = 'multi'  # 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 '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 '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
        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

        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(
            '/emails', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageEmailProjection',  # 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_gravatar_url_for_email_address(self, email_address, **kwargs):  # noqa: E501
        """get_gravatar_url_for_email_address  # noqa: E501

        Get gravatar url for email address  # 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_gravatar_url_for_email_address(email_address, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_address: (required)
        :param str size:
        :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: GravatarUrl
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_gravatar_url_for_email_address_with_http_info(email_address, **kwargs)  # noqa: E501

    def get_gravatar_url_for_email_address_with_http_info(self, email_address, **kwargs):  # noqa: E501
        """get_gravatar_url_for_email_address  # noqa: E501

        Get gravatar url for email address  # 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_gravatar_url_for_email_address_with_http_info(email_address, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_address: (required)
        :param str size:
        :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(GravatarUrl, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_address',
            'size'
        ]
        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_gravatar_url_for_email_address" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_address' is set
        if self.api_client.client_side_validation and ('email_address' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_address'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_address` when calling `get_gravatar_url_for_email_address`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'email_address' in local_var_params and local_var_params['email_address'] is not None:  # noqa: E501
            query_params.append(('emailAddress', local_var_params['email_address']))  # 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

        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(
            '/emails/gravatarFor', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='GravatarUrl',  # 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_latest_email(self, **kwargs):  # noqa: E501
        """Get latest email in all inboxes. Most recently received.  # noqa: E501

        Get the newest email in all inboxes or in a passed set of inbox IDs  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_latest_email(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param list[str] inbox_ids: Optional set of inboxes to filter by. Only get the latest email from these inbox IDs. If not provided will search across all inboxes
        :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: Email
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_latest_email_with_http_info(**kwargs)  # noqa: E501

    def get_latest_email_with_http_info(self, **kwargs):  # noqa: E501
        """Get latest email in all inboxes. Most recently received.  # noqa: E501

        Get the newest email in all inboxes or in a passed set of inbox IDs  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_latest_email_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param list[str] inbox_ids: Optional set of inboxes to filter by. Only get the latest email from these inbox IDs. If not provided will search across all inboxes
        :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 = [
            'inbox_ids'
        ]
        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_latest_email" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'inbox_ids' in local_var_params and local_var_params['inbox_ids'] is not None:  # noqa: E501
            query_params.append(('inboxIds', local_var_params['inbox_ids']))  # noqa: E501
            collection_formats['inboxIds'] = 'multi'  # 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(
            '/emails/latest', '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_latest_email_in_inbox1(self, inbox_id, **kwargs):  # noqa: E501
        """Get latest email in an inbox. Use `WaitForController` to get emails that may not have arrived yet.  # noqa: E501

        Get the newest email in all inboxes or in a passed set of inbox IDs  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_latest_email_in_inbox1(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of the inbox you want to get the latest email from (required)
        :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: Email
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_latest_email_in_inbox1_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def get_latest_email_in_inbox1_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """Get latest email in an inbox. Use `WaitForController` to get emails that may not have arrived yet.  # noqa: E501

        Get the newest email in all inboxes or in a passed set of inbox IDs  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_latest_email_in_inbox1_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of the inbox you want to get the latest email from (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(Email, status_code(int), headers(HTTPHeaderDict))
                 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 get_latest_email_in_inbox1" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `get_latest_email_in_inbox1`")  # 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
        # 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(
            '/emails/latestIn', '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_organization_emails_paginated(self, **kwargs):  # noqa: E501
        """Get all organization emails. List team or shared test email accounts  # noqa: E501

        By default returns all emails across all team inboxes sorted by ascending created at date. Responses are paginated. You can restrict results to a list of inbox IDs. You can also filter out read messages  # 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_organization_emails_paginated(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param list[str] inbox_id: Optional inbox ids to filter by. Can be repeated. By default will use all inboxes belonging to your account.
        :param int page: Optional page index in email list pagination
        :param int size: Optional page size in email list pagination. Maximum size is 100. Use page index and sort to page through larger results
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param bool unread_only: Optional filter for unread emails only. All emails are considered unread until they are viewed in the dashboard or requested directly
        :param str search_filter: Optional search filter search filter for emails.
        :param datetime since: Optional filter emails received after given date time. If unset will use time 24hours prior to now.
        :param datetime before: Optional filter emails received before given date time
        :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: PageEmailProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_organization_emails_paginated_with_http_info(**kwargs)  # noqa: E501

    def get_organization_emails_paginated_with_http_info(self, **kwargs):  # noqa: E501
        """Get all organization emails. List team or shared test email accounts  # noqa: E501

        By default returns all emails across all team inboxes sorted by ascending created at date. Responses are paginated. You can restrict results to a list of inbox IDs. You can also filter out read messages  # 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_organization_emails_paginated_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param list[str] inbox_id: Optional inbox ids to filter by. Can be repeated. By default will use all inboxes belonging to your account.
        :param int page: Optional page index in email list pagination
        :param int size: Optional page size in email list pagination. Maximum size is 100. Use page index and sort to page through larger results
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param bool unread_only: Optional filter for unread emails only. All emails are considered unread until they are viewed in the dashboard or requested directly
        :param str search_filter: Optional search filter search filter for emails.
        :param datetime since: Optional filter emails received after given date time. If unset will use time 24hours prior to now.
        :param datetime before: Optional filter emails received before given date 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(PageEmailProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort',
            'unread_only',
            'search_filter',
            '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 get_organization_emails_paginated" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        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_organization_emails_paginated`, must be a value less than or equal to `100`")  # 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
            collection_formats['inboxId'] = 'multi'  # 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 '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 '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
        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

        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(
            '/emails/organization', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageEmailProjection',  # 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_raw_email_contents(self, email_id, **kwargs):  # noqa: E501
        """Get raw email string. Returns unparsed raw SMTP message with headers and body.  # noqa: E501

        Returns a raw, unparsed, and unprocessed email. If your client has issues processing the response it is likely due to the response content-type which is text/plain. If you need a JSON response content-type use the getRawEmailJson endpoint  # 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_raw_email_contents(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_raw_email_contents_with_http_info(email_id, **kwargs)  # noqa: E501

    def get_raw_email_contents_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Get raw email string. Returns unparsed raw SMTP message with headers and body.  # noqa: E501

        Returns a raw, unparsed, and unprocessed email. If your client has issues processing the response it is likely due to the response content-type which is text/plain. If you need a JSON response content-type use the getRawEmailJson endpoint  # 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_raw_email_contents_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (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 = [
            'email_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_raw_email_contents" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_raw_email_contents`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_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(
            '/emails/{emailId}/raw', 'GET',
            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_raw_email_json(self, email_id, **kwargs):  # noqa: E501
        """Get raw email in JSON. Unparsed SMTP message in JSON wrapper format.  # noqa: E501

        Returns a raw, unparsed, and unprocessed email wrapped in a JSON response object for easier handling when compared with the getRawEmail text/plain response  # 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_raw_email_json(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (required)
        :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: RawEmailJson
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_raw_email_json_with_http_info(email_id, **kwargs)  # noqa: E501

    def get_raw_email_json_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Get raw email in JSON. Unparsed SMTP message in JSON wrapper format.  # noqa: E501

        Returns a raw, unparsed, and unprocessed email wrapped in a JSON response object for easier handling when compared with the getRawEmail text/plain response  # 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_raw_email_json_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (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(RawEmailJson, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_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_raw_email_json" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `get_raw_email_json`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/emails/{emailId}/raw/json', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='RawEmailJson',  # 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_unread_email_count(self, **kwargs):  # noqa: E501
        """Get unread email count  # noqa: E501

        Get number of emails unread. Unread means has not been viewed in dashboard or returned in an email API response  # 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_unread_email_count(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Optional inbox ID filter
        :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: UnreadCount
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_unread_email_count_with_http_info(**kwargs)  # noqa: E501

    def get_unread_email_count_with_http_info(self, **kwargs):  # noqa: E501
        """Get unread email count  # noqa: E501

        Get number of emails unread. Unread means has not been viewed in dashboard or returned in an email API response  # 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_unread_email_count_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: Optional inbox ID filter
        :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(UnreadCount, status_code(int), headers(HTTPHeaderDict))
                 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 get_unread_email_count" % 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
        # 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(
            '/emails/unreadCount', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='UnreadCount',  # 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 mark_all_as_read(self, **kwargs):  # noqa: E501
        """Mark all emails as read or unread  # noqa: E501

        Marks all emails as read or unread. Pass boolean read flag to set value. This is useful if you want to read an email but keep it as unread  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.mark_all_as_read(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param bool read: What value to assign to email read property. Default true.
        :param str inbox_id: Optional inbox ID filter
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.mark_all_as_read_with_http_info(**kwargs)  # noqa: E501

    def mark_all_as_read_with_http_info(self, **kwargs):  # noqa: E501
        """Mark all emails as read or unread  # noqa: E501

        Marks all emails as read or unread. Pass boolean read flag to set value. This is useful if you want to read an email but keep it as unread  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.mark_all_as_read_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param bool read: What value to assign to email read property. Default true.
        :param str inbox_id: Optional inbox ID filter
        :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 = [
            'read',
            '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 mark_all_as_read" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'read' in local_var_params and local_var_params['read'] is not None:  # noqa: E501
            query_params.append(('read', local_var_params['read']))  # 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

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/emails/read', 'PATCH',
            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 mark_as_read(self, email_id, **kwargs):  # noqa: E501
        """Mark an email as read or unread  # noqa: E501

        Marks an email as read or unread. Pass boolean read flag to set value. This is useful if you want to read an email but keep it as unread  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.mark_as_read(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param bool read: What value to assign to email read property. Default true.
        :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: EmailPreview
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.mark_as_read_with_http_info(email_id, **kwargs)  # noqa: E501

    def mark_as_read_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Mark an email as read or unread  # noqa: E501

        Marks an email as read or unread. Pass boolean read flag to set value. This is useful if you want to read an email but keep it as unread  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.mark_as_read_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param bool read: What value to assign to email read property. Default true.
        :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(EmailPreview, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'read'
        ]
        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 mark_as_read" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `mark_as_read`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []
        if 'read' in local_var_params and local_var_params['read'] is not None:  # noqa: E501
            query_params.append(('read', local_var_params['read']))  # 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(
            '/emails/{emailId}/read', 'PATCH',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='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 reply_to_email(self, email_id, reply_to_email_options, **kwargs):  # noqa: E501
        """Reply to an email  # noqa: E501

        Send the reply to the email sender or reply-to and include same subject cc bcc etc. Reply to an email and the contents will be sent with the existing subject to the emails `to`, `cc`, and `bcc`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.reply_to_email(email_id, reply_to_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of the email that should be replied to (required)
        :param ReplyToEmailOptions reply_to_email_options: (required)
        :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: SentEmailDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.reply_to_email_with_http_info(email_id, reply_to_email_options, **kwargs)  # noqa: E501

    def reply_to_email_with_http_info(self, email_id, reply_to_email_options, **kwargs):  # noqa: E501
        """Reply to an email  # noqa: E501

        Send the reply to the email sender or reply-to and include same subject cc bcc etc. Reply to an email and the contents will be sent with the existing subject to the emails `to`, `cc`, and `bcc`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.reply_to_email_with_http_info(email_id, reply_to_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of the email that should be replied to (required)
        :param ReplyToEmailOptions reply_to_email_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(SentEmailDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'reply_to_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 reply_to_email" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `reply_to_email`")  # noqa: E501
        # verify the required parameter 'reply_to_email_options' is set
        if self.api_client.client_side_validation and ('reply_to_email_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['reply_to_email_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `reply_to_email_options` when calling `reply_to_email`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'reply_to_email_options' in local_var_params:
            body_params = local_var_params['reply_to_email_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(
            '/emails/{emailId}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SentEmailDto',  # 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 search_emails(self, search_emails_options, **kwargs):  # noqa: E501
        """Get all emails by search criteria. Return in paginated form.  # noqa: E501

        Search emails by given criteria return matches in paginated format. Searches against email recipients, sender, subject, email address and ID. Does not search email body  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.search_emails(search_emails_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param SearchEmailsOptions search_emails_options: (required)
        :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: PageEmailProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.search_emails_with_http_info(search_emails_options, **kwargs)  # noqa: E501

    def search_emails_with_http_info(self, search_emails_options, **kwargs):  # noqa: E501
        """Get all emails by search criteria. Return in paginated form.  # noqa: E501

        Search emails by given criteria return matches in paginated format. Searches against email recipients, sender, subject, email address and ID. Does not search email body  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.search_emails_with_http_info(search_emails_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param SearchEmailsOptions search_emails_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(PageEmailProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'search_emails_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 search_emails" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'search_emails_options' is set
        if self.api_client.client_side_validation and ('search_emails_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['search_emails_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `search_emails_options` when calling `search_emails`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'search_emails_options' in local_var_params:
            body_params = local_var_params['search_emails_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(
            '/emails/search', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageEmailProjection',  # 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 send_email_source_optional(self, send_email_options, **kwargs):  # noqa: E501
        """Send email  # noqa: E501

        Alias for `InboxController.sendEmail` method - see original method for full details. Sends an email from a given inbox that you have created. If no inbox is supplied a random inbox will be created for you and used to send the 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.send_email_source_optional(send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param SendEmailOptions send_email_options: (required)
        :param str inbox_id: ID of the inbox you want to send the email from
        :param bool use_domain_pool: Use domain pool. Optionally create inbox to send from using the mailslurp domain pool.
        :param bool virtual_send: Optionally create inbox to send from that is a virtual inbox and won't send to external addresses
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.send_email_source_optional_with_http_info(send_email_options, **kwargs)  # noqa: E501

    def send_email_source_optional_with_http_info(self, send_email_options, **kwargs):  # noqa: E501
        """Send email  # noqa: E501

        Alias for `InboxController.sendEmail` method - see original method for full details. Sends an email from a given inbox that you have created. If no inbox is supplied a random inbox will be created for you and used to send the 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.send_email_source_optional_with_http_info(send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param SendEmailOptions send_email_options: (required)
        :param str inbox_id: ID of the inbox you want to send the email from
        :param bool use_domain_pool: Use domain pool. Optionally create inbox to send from using the mailslurp domain pool.
        :param bool virtual_send: Optionally create inbox to send from that is a virtual inbox and won't send to external addresses
        :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 = [
            'send_email_options',
            'inbox_id',
            'use_domain_pool',
            'virtual_send'
        ]
        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 send_email_source_optional" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'send_email_options' is set
        if self.api_client.client_side_validation and ('send_email_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['send_email_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `send_email_options` when calling `send_email_source_optional`")  # 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 '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
        if 'virtual_send' in local_var_params and local_var_params['virtual_send'] is not None:  # noqa: E501
            query_params.append(('virtualSend', local_var_params['virtual_send']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'send_email_options' in local_var_params:
            body_params = local_var_params['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(
            '/emails', '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 validate_email(self, email_id, **kwargs):  # noqa: E501
        """Validate email HTML contents  # noqa: E501

        Validate the HTML content of email if HTML is found. Considered valid if no HTML is present.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.validate_email(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (required)
        :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: ValidationDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.validate_email_with_http_info(email_id, **kwargs)  # noqa: E501

    def validate_email_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Validate email HTML contents  # noqa: E501

        Validate the HTML content of email if HTML is found. Considered valid if no HTML is present.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.validate_email_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email (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(ValidationDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_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 validate_email" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `validate_email`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/emails/{emailId}/validate', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ValidationDto',  # 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)

mailslurp_client/api/domain_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class DomainControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def add_domain_wildcard_catch_all(self, id, **kwargs):  # noqa: E501
        """Add catch all wild card inbox to domain  # noqa: E501

        Add a catch all inbox to a domain so that any emails sent to it that cannot be matched will be sent to the catch all inbox generated  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_domain_wildcard_catch_all(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :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: DomainDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.add_domain_wildcard_catch_all_with_http_info(id, **kwargs)  # noqa: E501

    def add_domain_wildcard_catch_all_with_http_info(self, id, **kwargs):  # noqa: E501
        """Add catch all wild card inbox to domain  # noqa: E501

        Add a catch all inbox to a domain so that any emails sent to it that cannot be matched will be sent to the catch all inbox generated  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_domain_wildcard_catch_all_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str 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: tuple(DomainDto, 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 add_domain_wildcard_catch_all" % 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 `add_domain_wildcard_catch_all`")  # 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/domains/{id}/wildcard', '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 create_domain(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(create_domain_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateDomainOptions create_domain_options: (required)
        :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: DomainDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_domain_with_http_info(create_domain_options, **kwargs)  # noqa: E501

    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 delete_domain(self, id, **kwargs):  # noqa: E501
        """Delete a domain  # noqa: E501

        Delete a domain. This will disable any existing inboxes that use this 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.delete_domain(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :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: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_domain_with_http_info(id, **kwargs)  # noqa: E501

    def delete_domain_with_http_info(self, id, **kwargs):  # noqa: E501
        """Delete a domain  # noqa: E501

        Delete a domain. This will disable any existing inboxes that use this 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.delete_domain_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str 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: tuple(list[str], 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 delete_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 `delete_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
        # 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(
            '/domains/{id}', 'DELETE',
            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 get_available_domains(self, **kwargs):  # noqa: E501
        """Get all usable domains  # noqa: E501

        List all domains available for use with email address creation  # 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_available_domains(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_type:
        :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: DomainGroupsDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_available_domains_with_http_info(**kwargs)  # noqa: E501

    def get_available_domains_with_http_info(self, **kwargs):  # noqa: E501
        """Get all usable domains  # noqa: E501

        List all domains available for use with email address creation  # 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_available_domains_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_type:
        :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(DomainGroupsDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_type'
        ]
        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_available_domains" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'inbox_type' in local_var_params and local_var_params['inbox_type'] is not None:  # noqa: E501
            query_params.append(('inboxType', local_var_params['inbox_type']))  # 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(
            '/domains/available-domains', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DomainGroupsDto',  # 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_domain(self, id, **kwargs):  # noqa: E501
        """Get a domain  # noqa: E501

        Returns domain verification status and tokens for a given 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.get_domain(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param bool check_for_errors:
        :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: DomainDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_domain_with_http_info(id, **kwargs)  # noqa: E501

    def get_domain_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get a domain  # noqa: E501

        Returns domain verification status and tokens for a given 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.get_domain_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param bool check_for_errors:
        :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',
            'check_for_errors'
        ]
        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_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 `get_domain`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []
        if 'check_for_errors' in local_var_params and local_var_params['check_for_errors'] is not None:  # noqa: E501
            query_params.append(('checkForErrors', local_var_params['check_for_errors']))  # 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(
            '/domains/{id}', 'GET',
            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 get_domain_issues(self, **kwargs):  # noqa: E501
        """Get domain issues  # noqa: E501

        List domain issues for domains you have created  # 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_domain_issues(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: DomainIssuesDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_domain_issues_with_http_info(**kwargs)  # noqa: E501

    def get_domain_issues_with_http_info(self, **kwargs):  # noqa: E501
        """Get domain issues  # noqa: E501

        List domain issues for domains you have created  # 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_domain_issues_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(DomainIssuesDto, 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_domain_issues" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/domains/issues', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DomainIssuesDto',  # 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_domain_wildcard_catch_all_inbox(self, id, **kwargs):  # noqa: E501
        """Get catch all wild card inbox for domain  # noqa: E501

        Get the catch all inbox for a domain for missed 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.get_domain_wildcard_catch_all_inbox(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :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: InboxDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_domain_wildcard_catch_all_inbox_with_http_info(id, **kwargs)  # noqa: E501

    def get_domain_wildcard_catch_all_inbox_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get catch all wild card inbox for domain  # noqa: E501

        Get the catch all inbox for a domain for missed 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.get_domain_wildcard_catch_all_inbox_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str 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: tuple(InboxDto, 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_domain_wildcard_catch_all_inbox" % 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_domain_wildcard_catch_all_inbox`")  # 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/domains/{id}/wildcard', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxDto',  # 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_domains(self, **kwargs):  # noqa: E501
        """Get domains  # noqa: E501

        List all custom domains you have created  # 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_domains(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: list[DomainPreview]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_domains_with_http_info(**kwargs)  # noqa: E501

    def get_domains_with_http_info(self, **kwargs):  # noqa: E501
        """Get domains  # noqa: E501

        List all custom domains you have created  # 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_domains_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(list[DomainPreview], 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_domains" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/domains', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[DomainPreview]',  # 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_mail_slurp_domains(self, **kwargs):  # noqa: E501
        """Get MailSlurp domains  # noqa: E501

        List all MailSlurp domains used with non-custom 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.get_mail_slurp_domains(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_type:
        :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: DomainGroupsDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_mail_slurp_domains_with_http_info(**kwargs)  # noqa: E501

    def get_mail_slurp_domains_with_http_info(self, **kwargs):  # noqa: E501
        """Get MailSlurp domains  # noqa: E501

        List all MailSlurp domains used with non-custom 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.get_mail_slurp_domains_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_type:
        :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(DomainGroupsDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_type'
        ]
        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_mail_slurp_domains" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'inbox_type' in local_var_params and local_var_params['inbox_type'] is not None:  # noqa: E501
            query_params.append(('inboxType', local_var_params['inbox_type']))  # 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(
            '/domains/mailslurp-domains', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DomainGroupsDto',  # 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(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(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 _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: DomainDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_domain_with_http_info(id, update_domain_options, **kwargs)  # noqa: E501

    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)

mailslurp_client/api/contact_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class ContactControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def create_contact(self, create_contact_options, **kwargs):  # noqa: E501
        """Create a contact  # 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_contact(create_contact_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateContactOptions create_contact_options: (required)
        :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: ContactDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_contact_with_http_info(create_contact_options, **kwargs)  # noqa: E501

    def create_contact_with_http_info(self, create_contact_options, **kwargs):  # noqa: E501
        """Create a contact  # 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_contact_with_http_info(create_contact_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateContactOptions create_contact_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(ContactDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_contact_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_contact" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'create_contact_options' is set
        if self.api_client.client_side_validation and ('create_contact_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_contact_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_contact_options` when calling `create_contact`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_contact_options' in local_var_params:
            body_params = local_var_params['create_contact_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(
            '/contacts', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ContactDto',  # 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_contact(self, contact_id, **kwargs):  # noqa: E501
        """Delete contact  # 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_contact(contact_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str contact_id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_contact_with_http_info(contact_id, **kwargs)  # noqa: E501

    def delete_contact_with_http_info(self, contact_id, **kwargs):  # noqa: E501
        """Delete contact  # 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_contact_with_http_info(contact_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str contact_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 = [
            'contact_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_contact" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'contact_id' is set
        if self.api_client.client_side_validation and ('contact_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['contact_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `contact_id` when calling `delete_contact`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'contact_id' in local_var_params:
            path_params['contactId'] = local_var_params['contact_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(
            '/contacts/{contactId}', '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_all_contacts(self, **kwargs):  # noqa: E501
        """Get all contacts  # 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_all_contacts(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 in list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :param str search: Search terms
        :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: PageContactProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_all_contacts_with_http_info(**kwargs)  # noqa: E501

    def get_all_contacts_with_http_info(self, **kwargs):  # noqa: E501
        """Get all contacts  # 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_all_contacts_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 in list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :param str search: Search terms
        :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 = [
            'page',
            'size',
            'sort',
            'since',
            'before',
            'search'
        ]
        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_all_contacts" % 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
        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 'search' in local_var_params and local_var_params['search'] is not None:  # noqa: E501
            query_params.append(('search', local_var_params['search']))  # 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(
            '/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 get_contact(self, contact_id, **kwargs):  # noqa: E501
        """Get contact  # 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_contact(contact_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str contact_id: (required)
        :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: ContactDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_contact_with_http_info(contact_id, **kwargs)  # noqa: E501

    def get_contact_with_http_info(self, contact_id, **kwargs):  # noqa: E501
        """Get contact  # 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_contact_with_http_info(contact_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str contact_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: tuple(ContactDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'contact_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_contact" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'contact_id' is set
        if self.api_client.client_side_validation and ('contact_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['contact_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `contact_id` when calling `get_contact`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'contact_id' in local_var_params:
            path_params['contactId'] = local_var_params['contact_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/contacts/{contactId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ContactDto',  # 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_contact_v_card(self, contact_id, **kwargs):  # noqa: E501
        """Get contact vCard vcf file  # 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_contact_v_card(contact_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str contact_id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_contact_v_card_with_http_info(contact_id, **kwargs)  # noqa: E501

    def get_contact_v_card_with_http_info(self, contact_id, **kwargs):  # noqa: E501
        """Get contact vCard vcf file  # 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_contact_v_card_with_http_info(contact_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str contact_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 = [
            'contact_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_contact_v_card" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'contact_id' is set
        if self.api_client.client_side_validation and ('contact_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['contact_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `contact_id` when calling `get_contact_v_card`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'contact_id' in local_var_params:
            path_params['contactId'] = local_var_params['contact_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(
            '/contacts/{contactId}/download', 'GET',
            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_contacts(self, **kwargs):  # noqa: E501
        """Get all contacts  # 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_contacts(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: list[ContactProjection]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_contacts_with_http_info(**kwargs)  # noqa: E501

    def get_contacts_with_http_info(self, **kwargs):  # noqa: E501
        """Get all contacts  # 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_contacts_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(list[ContactProjection], 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_contacts" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/contacts', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[ContactProjection]',  # 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)

mailslurp_client/api/connector_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class ConnectorControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def create_connector(self, create_connector_options, **kwargs):  # noqa: E501
        """Create an inbox connector  # noqa: E501

        Sync emails between external mailboxes and MailSlurp inboxes  # 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_connector(create_connector_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateConnectorOptions create_connector_options: (required)
        :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: ConnectorDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_connector_with_http_info(create_connector_options, **kwargs)  # noqa: E501

    def create_connector_with_http_info(self, create_connector_options, **kwargs):  # noqa: E501
        """Create an inbox connector  # noqa: E501

        Sync emails between external mailboxes and MailSlurp inboxes  # 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_connector_with_http_info(create_connector_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateConnectorOptions create_connector_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(ConnectorDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_connector_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_connector" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'create_connector_options' is set
        if self.api_client.client_side_validation and ('create_connector_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_connector_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_connector_options` when calling `create_connector`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_connector_options' in local_var_params:
            body_params = local_var_params['create_connector_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(
            '/connectors', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ConnectorDto',  # 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_connector_imap_connection(self, id, create_connector_imap_connection_options, **kwargs):  # noqa: E501
        """Create an inbox connector IMAP connection  # noqa: E501

        Allows the reading of emails in an external mailbox and syncing to a MailSlurp 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.create_connector_imap_connection(id, create_connector_imap_connection_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param CreateConnectorImapConnectionOptions create_connector_imap_connection_options: (required)
        :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: ConnectorImapConnectionDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_connector_imap_connection_with_http_info(id, create_connector_imap_connection_options, **kwargs)  # noqa: E501

    def create_connector_imap_connection_with_http_info(self, id, create_connector_imap_connection_options, **kwargs):  # noqa: E501
        """Create an inbox connector IMAP connection  # noqa: E501

        Allows the reading of emails in an external mailbox and syncing to a MailSlurp 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.create_connector_imap_connection_with_http_info(id, create_connector_imap_connection_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param CreateConnectorImapConnectionOptions create_connector_imap_connection_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(ConnectorImapConnectionDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'id',
            'create_connector_imap_connection_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_connector_imap_connection" % 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 `create_connector_imap_connection`")  # noqa: E501
        # verify the required parameter 'create_connector_imap_connection_options' is set
        if self.api_client.client_side_validation and ('create_connector_imap_connection_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_connector_imap_connection_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_connector_imap_connection_options` when calling `create_connector_imap_connection`")  # 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 'create_connector_imap_connection_options' in local_var_params:
            body_params = local_var_params['create_connector_imap_connection_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(
            '/connectors/{id}/imap', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ConnectorImapConnectionDto',  # 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_connector_smtp_connection(self, id, create_connector_smtp_connection_options, **kwargs):  # noqa: E501
        """Create an inbox connector SMTP connection  # noqa: E501

        Allows sending via connector and email is routed to connected inbox and sent via SMTP  # 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_connector_smtp_connection(id, create_connector_smtp_connection_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param CreateConnectorSmtpConnectionOptions create_connector_smtp_connection_options: (required)
        :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: ConnectorSmtpConnectionDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_connector_smtp_connection_with_http_info(id, create_connector_smtp_connection_options, **kwargs)  # noqa: E501

    def create_connector_smtp_connection_with_http_info(self, id, create_connector_smtp_connection_options, **kwargs):  # noqa: E501
        """Create an inbox connector SMTP connection  # noqa: E501

        Allows sending via connector and email is routed to connected inbox and sent via SMTP  # 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_connector_smtp_connection_with_http_info(id, create_connector_smtp_connection_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param CreateConnectorSmtpConnectionOptions create_connector_smtp_connection_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(ConnectorSmtpConnectionDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'id',
            'create_connector_smtp_connection_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_connector_smtp_connection" % 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 `create_connector_smtp_connection`")  # noqa: E501
        # verify the required parameter 'create_connector_smtp_connection_options' is set
        if self.api_client.client_side_validation and ('create_connector_smtp_connection_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_connector_smtp_connection_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_connector_smtp_connection_options` when calling `create_connector_smtp_connection`")  # 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 'create_connector_smtp_connection_options' in local_var_params:
            body_params = local_var_params['create_connector_smtp_connection_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(
            '/connectors/{id}/smtp', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ConnectorSmtpConnectionDto',  # 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_all_connector(self, **kwargs):  # noqa: E501
        """Delete all inbox connectors  # 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_all_connector(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_all_connector_with_http_info(**kwargs)  # noqa: E501

    def delete_all_connector_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all inbox connectors  # 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_all_connector_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: None
                 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 delete_all_connector" % 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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/connectors', '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 delete_connector(self, id, **kwargs):  # noqa: E501
        """Delete an inbox connector  # 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_connector(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_connector_with_http_info(id, **kwargs)  # noqa: E501

    def delete_connector_with_http_info(self, id, **kwargs):  # noqa: E501
        """Delete an inbox connector  # 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_connector_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str 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 = [
            '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_connector" % 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 `delete_connector`")  # 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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/connectors/{id}', '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 delete_connector_imap_connection(self, id, **kwargs):  # noqa: E501
        """Delete an inbox connector IMAP connection  # noqa: E501

        Delete IMAP connection for external 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.delete_connector_imap_connection(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_connector_imap_connection_with_http_info(id, **kwargs)  # noqa: E501

    def delete_connector_imap_connection_with_http_info(self, id, **kwargs):  # noqa: E501
        """Delete an inbox connector IMAP connection  # noqa: E501

        Delete IMAP connection for external 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.delete_connector_imap_connection_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str 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 = [
            '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_connector_imap_connection" % 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 `delete_connector_imap_connection`")  # 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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/connectors/{id}/imap', '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 delete_connector_smtp_connection(self, id, **kwargs):  # noqa: E501
        """Delete an inbox connector SMTP connection  # noqa: E501

        Delete SMTP connection for external 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.delete_connector_smtp_connection(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_connector_smtp_connection_with_http_info(id, **kwargs)  # noqa: E501

    def delete_connector_smtp_connection_with_http_info(self, id, **kwargs):  # noqa: E501
        """Delete an inbox connector SMTP connection  # noqa: E501

        Delete SMTP connection for external 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.delete_connector_smtp_connection_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str 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 = [
            '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_connector_smtp_connection" % 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 `delete_connector_smtp_connection`")  # 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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/connectors/{id}/smtp', '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_all_connector_sync_events(self, **kwargs):  # noqa: E501
        """Get all inbox connector sync events  # 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_all_connector_sync_events(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index in connector list pagination
        :param int size: Optional page size in connector list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageConnectorSyncEvents
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_all_connector_sync_events_with_http_info(**kwargs)  # noqa: E501

    def get_all_connector_sync_events_with_http_info(self, **kwargs):  # noqa: E501
        """Get all inbox connector sync events  # 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_all_connector_sync_events_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index in connector list pagination
        :param int size: Optional page size in connector list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PageConnectorSyncEvents, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            '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 get_all_connector_sync_events" % 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
        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(
            '/connectors/events', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageConnectorSyncEvents',  # 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_connector(self, id, **kwargs):  # noqa: E501
        """Get an inbox connector  # 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_connector(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :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: ConnectorDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_connector_with_http_info(id, **kwargs)  # noqa: E501

    def get_connector_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get an inbox connector  # 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_connector_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str 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: tuple(ConnectorDto, 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_connector" % 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_connector`")  # 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/connectors/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ConnectorDto',  # 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_connector_sync_event(self, id, **kwargs):  # noqa: E501
        """Get an inbox connector sync event  # 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_connector_sync_event(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :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: ConnectorSyncEventDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_connector_sync_event_with_http_info(id, **kwargs)  # noqa: E501

    def get_connector_sync_event_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get an inbox connector sync event  # 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_connector_sync_event_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str 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: tuple(ConnectorSyncEventDto, 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_connector_sync_event" % 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_connector_sync_event`")  # 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/connectors/events/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ConnectorSyncEventDto',  # 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_connector_sync_events(self, id, **kwargs):  # noqa: E501
        """Get an inbox connector sync events  # 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_connector_sync_events(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param int page: Optional page index in connector list pagination
        :param int size: Optional page size in connector list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageConnectorSyncEvents
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_connector_sync_events_with_http_info(id, **kwargs)  # noqa: E501

    def get_connector_sync_events_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get an inbox connector sync events  # 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_connector_sync_events_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param int page: Optional page index in connector list pagination
        :param int size: Optional page size in connector list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PageConnectorSyncEvents, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'id',
            'page',
            'size',
            'sort',
            '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 get_connector_sync_events" % 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_connector_sync_events`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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
        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(
            '/connectors/{id}/events', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageConnectorSyncEvents',  # 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_connectors(self, **kwargs):  # noqa: E501
        """Get inbox connectors  # noqa: E501

        List inbox connectors that sync external emails to MailSlurp inboxes  # 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_connectors(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index in connector list pagination
        :param int size: Optional page size in connector list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageConnector
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_connectors_with_http_info(**kwargs)  # noqa: E501

    def get_connectors_with_http_info(self, **kwargs):  # noqa: E501
        """Get inbox connectors  # noqa: E501

        List inbox connectors that sync external emails to MailSlurp inboxes  # 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_connectors_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index in connector list pagination
        :param int size: Optional page size in connector list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PageConnector, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            '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 get_connectors" % 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
        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(
            '/connectors', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageConnector',  # 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 sync_connector(self, id, **kwargs):  # noqa: E501
        """Sync an inbox connector  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.sync_connector(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :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: ConnectorSyncRequestResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.sync_connector_with_http_info(id, **kwargs)  # noqa: E501

    def sync_connector_with_http_info(self, id, **kwargs):  # noqa: E501
        """Sync an inbox connector  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.sync_connector_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str 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: tuple(ConnectorSyncRequestResult, 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 sync_connector" % 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 `sync_connector`")  # 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/connectors/{id}/sync', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ConnectorSyncRequestResult',  # 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_connector(self, id, create_connector_options, **kwargs):  # noqa: E501
        """Update an inbox connector  # 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_connector(id, create_connector_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param CreateConnectorOptions create_connector_options: (required)
        :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: ConnectorDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_connector_with_http_info(id, create_connector_options, **kwargs)  # noqa: E501

    def update_connector_with_http_info(self, id, create_connector_options, **kwargs):  # noqa: E501
        """Update an inbox connector  # 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_connector_with_http_info(id, create_connector_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param CreateConnectorOptions create_connector_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(ConnectorDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'id',
            'create_connector_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_connector" % 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_connector`")  # noqa: E501
        # verify the required parameter 'create_connector_options' is set
        if self.api_client.client_side_validation and ('create_connector_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_connector_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_connector_options` when calling `update_connector`")  # 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 'create_connector_options' in local_var_params:
            body_params = local_var_params['create_connector_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(
            '/connectors/{id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ConnectorDto',  # 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)

mailslurp_client/api/common_actions_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class CommonActionsControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def create_new_email_address(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(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param bool allow_team_access:
        :param bool use_domain_pool:
        :param datetime expires_at:
        :param int expires_in:
        :param str email_address:
        :param str inbox_type:
        :param str description:
        :param str name:
        :param list[str] tags:
        :param bool favourite:
        :param bool virtual_inbox:
        :param bool use_short_address:
        :param str domain_name:
        :param str domain_id:
        :param str prefix:
        :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: InboxDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_new_email_address_with_http_info(**kwargs)  # noqa: E501

    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:
        :param bool use_domain_pool:
        :param datetime expires_at:
        :param int expires_in:
        :param str email_address:
        :param str inbox_type:
        :param str description:
        :param str name:
        :param list[str] tags:
        :param bool favourite:
        :param bool virtual_inbox:
        :param bool use_short_address:
        :param str domain_name:
        :param str domain_id:
        :param str prefix:
        :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(InboxDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'allow_team_access',
            'use_domain_pool',
            'expires_at',
            'expires_in',
            'email_address',
            'inbox_type',
            'description',
            'name',
            'tags',
            'favourite',
            'virtual_inbox',
            'use_short_address',
            'domain_name',
            'domain_id',
            'prefix'
        ]
        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 '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
        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 'email_address' in local_var_params and local_var_params['email_address'] is not None:  # noqa: E501
            query_params.append(('emailAddress', local_var_params['email_address']))  # noqa: E501
        if 'inbox_type' in local_var_params and local_var_params['inbox_type'] is not None:  # noqa: E501
            query_params.append(('inboxType', local_var_params['inbox_type']))  # noqa: E501
        if 'description' in local_var_params and local_var_params['description'] is not None:  # noqa: E501
            query_params.append(('description', local_var_params['description']))  # noqa: E501
        if 'name' in local_var_params and local_var_params['name'] is not None:  # noqa: E501
            query_params.append(('name', local_var_params['name']))  # noqa: E501
        if 'tags' in local_var_params and local_var_params['tags'] is not None:  # noqa: E501
            query_params.append(('tags', local_var_params['tags']))  # noqa: E501
            collection_formats['tags'] = 'multi'  # noqa: E501
        if 'favourite' in local_var_params and local_var_params['favourite'] is not None:  # noqa: E501
            query_params.append(('favourite', local_var_params['favourite']))  # noqa: E501
        if 'virtual_inbox' in local_var_params and local_var_params['virtual_inbox'] is not None:  # noqa: E501
            query_params.append(('virtualInbox', local_var_params['virtual_inbox']))  # noqa: E501
        if 'use_short_address' in local_var_params and local_var_params['use_short_address'] is not None:  # noqa: E501
            query_params.append(('useShortAddress', local_var_params['use_short_address']))  # noqa: E501
        if 'domain_name' in local_var_params and local_var_params['domain_name'] is not None:  # noqa: E501
            query_params.append(('domainName', local_var_params['domain_name']))  # noqa: E501
        if 'domain_id' in local_var_params and local_var_params['domain_id'] is not None:  # noqa: E501
            query_params.append(('domainId', local_var_params['domain_id']))  # noqa: E501
        if 'prefix' in local_var_params and local_var_params['prefix'] is not None:  # noqa: E501
            query_params.append(('prefix', local_var_params['prefix']))  # 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(
            '/newEmailAddress', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxDto',  # 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_random_inbox(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_random_inbox(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param bool allow_team_access:
        :param bool use_domain_pool:
        :param datetime expires_at:
        :param int expires_in:
        :param str email_address:
        :param str inbox_type:
        :param str description:
        :param str name:
        :param list[str] tags:
        :param bool favourite:
        :param bool virtual_inbox:
        :param bool use_short_address:
        :param str domain_name:
        :param str domain_id:
        :param str prefix:
        :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: InboxDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_random_inbox_with_http_info(**kwargs)  # noqa: E501

    def create_random_inbox_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_random_inbox_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param bool allow_team_access:
        :param bool use_domain_pool:
        :param datetime expires_at:
        :param int expires_in:
        :param str email_address:
        :param str inbox_type:
        :param str description:
        :param str name:
        :param list[str] tags:
        :param bool favourite:
        :param bool virtual_inbox:
        :param bool use_short_address:
        :param str domain_name:
        :param str domain_id:
        :param str prefix:
        :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(InboxDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'allow_team_access',
            'use_domain_pool',
            'expires_at',
            'expires_in',
            'email_address',
            'inbox_type',
            'description',
            'name',
            'tags',
            'favourite',
            'virtual_inbox',
            'use_short_address',
            'domain_name',
            'domain_id',
            'prefix'
        ]
        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_random_inbox" % 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 '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
        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 'email_address' in local_var_params and local_var_params['email_address'] is not None:  # noqa: E501
            query_params.append(('emailAddress', local_var_params['email_address']))  # noqa: E501
        if 'inbox_type' in local_var_params and local_var_params['inbox_type'] is not None:  # noqa: E501
            query_params.append(('inboxType', local_var_params['inbox_type']))  # noqa: E501
        if 'description' in local_var_params and local_var_params['description'] is not None:  # noqa: E501
            query_params.append(('description', local_var_params['description']))  # noqa: E501
        if 'name' in local_var_params and local_var_params['name'] is not None:  # noqa: E501
            query_params.append(('name', local_var_params['name']))  # noqa: E501
        if 'tags' in local_var_params and local_var_params['tags'] is not None:  # noqa: E501
            query_params.append(('tags', local_var_params['tags']))  # noqa: E501
            collection_formats['tags'] = 'multi'  # noqa: E501
        if 'favourite' in local_var_params and local_var_params['favourite'] is not None:  # noqa: E501
            query_params.append(('favourite', local_var_params['favourite']))  # noqa: E501
        if 'virtual_inbox' in local_var_params and local_var_params['virtual_inbox'] is not None:  # noqa: E501
            query_params.append(('virtualInbox', local_var_params['virtual_inbox']))  # noqa: E501
        if 'use_short_address' in local_var_params and local_var_params['use_short_address'] is not None:  # noqa: E501
            query_params.append(('useShortAddress', local_var_params['use_short_address']))  # noqa: E501
        if 'domain_name' in local_var_params and local_var_params['domain_name'] is not None:  # noqa: E501
            query_params.append(('domainName', local_var_params['domain_name']))  # noqa: E501
        if 'domain_id' in local_var_params and local_var_params['domain_id'] is not None:  # noqa: E501
            query_params.append(('domainId', local_var_params['domain_id']))  # noqa: E501
        if 'prefix' in local_var_params and local_var_params['prefix'] is not None:  # noqa: E501
            query_params.append(('prefix', local_var_params['prefix']))  # 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(
            '/createInbox', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxDto',  # 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_email_address(self, inbox_id, **kwargs):  # noqa: E501
        """Delete inbox email address by inbox id  # noqa: E501

        Deletes inbox email address  # 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_email_address(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_email_address_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def delete_email_address_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """Delete inbox email address by inbox id  # noqa: E501

        Deletes inbox email address  # 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_email_address_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_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 = [
            '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_email_address" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `delete_email_address`")  # 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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/deleteEmailAddress', '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 empty_inbox(self, inbox_id, **kwargs):  # noqa: E501
        """Delete all emails in an inbox  # noqa: E501

        Deletes all 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.empty_inbox(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.empty_inbox_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def empty_inbox_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """Delete all emails in an inbox  # noqa: E501

        Deletes all 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.empty_inbox_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_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 = [
            '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 empty_inbox" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `empty_inbox`")  # 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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/emptyInbox', '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 send_email_query(self, to, **kwargs):  # noqa: E501
        """Send an email using query parameters  # noqa: E501

        If no senderId or inboxId provided a random email address will be used to send from. Ensure your parameters are URL encoded.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.send_email_query(to, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str to: Email address to send to (required)
        :param str sender_id: ID of inbox to send from. If null an inbox will be created for sending
        :param str body: Body of the email message. Supports HTML
        :param str subject: Subject line of the email
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.send_email_query_with_http_info(to, **kwargs)  # noqa: E501

    def send_email_query_with_http_info(self, to, **kwargs):  # noqa: E501
        """Send an email using query parameters  # noqa: E501

        If no senderId or inboxId provided a random email address will be used to send from. Ensure your parameters are URL encoded.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.send_email_query_with_http_info(to, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str to: Email address to send to (required)
        :param str sender_id: ID of inbox to send from. If null an inbox will be created for sending
        :param str body: Body of the email message. Supports HTML
        :param str subject: Subject line of the email
        :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 = [
            'to',
            'sender_id',
            'body',
            'subject'
        ]
        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 send_email_query" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'to' is set
        if self.api_client.client_side_validation and ('to' not in local_var_params or  # noqa: E501
                                                        local_var_params['to'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `to` when calling `send_email_query`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'sender_id' in local_var_params and local_var_params['sender_id'] is not None:  # noqa: E501
            query_params.append(('senderId', local_var_params['sender_id']))  # noqa: E501
        if 'to' in local_var_params and local_var_params['to'] is not None:  # noqa: E501
            query_params.append(('to', local_var_params['to']))  # noqa: E501
        if 'body' in local_var_params and local_var_params['body'] is not None:  # noqa: E501
            query_params.append(('body', local_var_params['body']))  # noqa: E501
        if 'subject' in local_var_params and local_var_params['subject'] is not None:  # noqa: E501
            query_params.append(('subject', local_var_params['subject']))  # 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(
            '/sendEmailQuery', '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 send_email_simple(self, simple_send_email_options, **kwargs):  # noqa: E501
        """Send an email  # noqa: E501

        If no senderId or inboxId provided a random email address will be used to send from.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.send_email_simple(simple_send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param SimpleSendEmailOptions simple_send_email_options: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.send_email_simple_with_http_info(simple_send_email_options, **kwargs)  # noqa: E501

    def send_email_simple_with_http_info(self, simple_send_email_options, **kwargs):  # noqa: E501
        """Send an email  # noqa: E501

        If no senderId or inboxId provided a random email address will be used to send from.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.send_email_simple_with_http_info(simple_send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param SimpleSendEmailOptions simple_send_email_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: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'simple_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 send_email_simple" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'simple_send_email_options' is set
        if self.api_client.client_side_validation and ('simple_send_email_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['simple_send_email_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `simple_send_email_options` when calling `send_email_simple`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'simple_send_email_options' in local_var_params:
            body_params = local_var_params['simple_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(
            '/sendEmail', '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)

mailslurp_client/api/bulk_actions_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class BulkActionsControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def bulk_create_inboxes(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(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 _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: list[InboxDto]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.bulk_create_inboxes_with_http_info(count, **kwargs)  # noqa: E501

    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[InboxDto], 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(
            ['*/*'])  # 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[InboxDto]',  # 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_delete_inboxes(self, request_body, **kwargs):  # noqa: E501
        """Bulk Delete Inboxes  # 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_delete_inboxes(request_body, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param list[str] request_body: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.bulk_delete_inboxes_with_http_info(request_body, **kwargs)  # noqa: E501

    def bulk_delete_inboxes_with_http_info(self, request_body, **kwargs):  # noqa: E501
        """Bulk Delete Inboxes  # 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_delete_inboxes_with_http_info(request_body, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param list[str] request_body: (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 = [
            'request_body'
        ]
        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_delete_inboxes" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'request_body' is set
        if self.api_client.client_side_validation and ('request_body' not in local_var_params or  # noqa: E501
                                                        local_var_params['request_body'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `request_body` when calling `bulk_delete_inboxes`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'request_body' in local_var_params:
            body_params = local_var_params['request_body']
        # 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/inboxes', '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_send_emails(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(bulk_send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param BulkSendEmailOptions bulk_send_email_options: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.bulk_send_emails_with_http_info(bulk_send_email_options, **kwargs)  # noqa: E501

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

mailslurp_client/api/bounce_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class BounceControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def filter_bounced_recipient(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(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 _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: FilterBouncedRecipientsResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.filter_bounced_recipient_with_http_info(filter_bounced_recipients_options, **kwargs)  # noqa: E501

    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 get_account_bounce_block_status(self, **kwargs):  # noqa: E501
        """Can account send email  # noqa: E501

        Check if account block status prevents sending  # 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_account_bounce_block_status(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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: AccountBounceBlockDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_account_bounce_block_status_with_http_info(**kwargs)  # noqa: E501

    def get_account_bounce_block_status_with_http_info(self, **kwargs):  # noqa: E501
        """Can account send email  # noqa: E501

        Check if account block status prevents sending  # 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_account_bounce_block_status_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(AccountBounceBlockDto, 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_account_bounce_block_status" % 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/bounce/account-block', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AccountBounceBlockDto',  # 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_bounced_email(self, id, **kwargs):  # noqa: E501
        """Get a bounced email.  # noqa: E501

        Bounced emails are email you have sent that were rejected by a recipient  # 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_bounced_email(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of the bounced email to fetch (required)
        :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: BouncedEmailDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_bounced_email_with_http_info(id, **kwargs)  # noqa: E501

    def get_bounced_email_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get a bounced email.  # noqa: E501

        Bounced emails are email you have sent that were rejected by a recipient  # 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_bounced_email_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of the bounced email to fetch (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(BouncedEmailDto, 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_bounced_email" % 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_bounced_email`")  # 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/bounce/emails/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='BouncedEmailDto',  # 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_bounced_emails(self, **kwargs):  # noqa: E501
        """Get paginated list of bounced emails.  # noqa: E501

        Bounced emails are email you have sent that were rejected by a recipient  # 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_bounced_emails(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index
        :param int size: Optional page size 
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageBouncedEmail
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_bounced_emails_with_http_info(**kwargs)  # noqa: E501

    def get_bounced_emails_with_http_info(self, **kwargs):  # noqa: E501
        """Get paginated list of bounced emails.  # noqa: E501

        Bounced emails are email you have sent that were rejected by a recipient  # 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_bounced_emails_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index
        :param int size: Optional page size 
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PageBouncedEmail, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            '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 get_bounced_emails" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        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_bounced_emails`, must be a value less than or equal to `100`")  # 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 '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(
            '/bounce/emails', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageBouncedEmail',  # 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_bounced_recipient(self, id, **kwargs):  # noqa: E501
        """Get a bounced email.  # noqa: E501

        Bounced emails are email you have sent that were rejected by a recipient  # 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_bounced_recipient(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of the bounced recipient (required)
        :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: BouncedRecipientDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_bounced_recipient_with_http_info(id, **kwargs)  # noqa: E501

    def get_bounced_recipient_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get a bounced email.  # noqa: E501

        Bounced emails are email you have sent that were rejected by a recipient  # 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_bounced_recipient_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of the bounced recipient (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(BouncedRecipientDto, 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_bounced_recipient" % 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_bounced_recipient`")  # 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/bounce/recipients/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='BouncedRecipientDto',  # 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_bounced_recipients(self, **kwargs):  # noqa: E501
        """Get paginated list of bounced recipients.  # noqa: E501

        Bounced recipients are email addresses that you have sent emails to that did not accept the sent email. Once a recipient is bounced you cannot send emails to that address.  # 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_bounced_recipients(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index 
        :param int size: Optional page size 
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageBouncedRecipients
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_bounced_recipients_with_http_info(**kwargs)  # noqa: E501

    def get_bounced_recipients_with_http_info(self, **kwargs):  # noqa: E501
        """Get paginated list of bounced recipients.  # noqa: E501

        Bounced recipients are email addresses that you have sent emails to that did not accept the sent email. Once a recipient is bounced you cannot send emails to that address.  # 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_bounced_recipients_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index 
        :param int size: Optional page size 
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PageBouncedRecipients, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            '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 get_bounced_recipients" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        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_bounced_recipients`, must be a value less than or equal to `100`")  # 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 '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(
            '/bounce/recipients', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageBouncedRecipients',  # 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_complaint(self, id, **kwargs):  # noqa: E501
        """Get complaint  # noqa: E501

        Get complaint  # 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_complaint(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of the complaint (required)
        :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: Complaint
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_complaint_with_http_info(id, **kwargs)  # noqa: E501

    def get_complaint_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get complaint  # noqa: E501

        Get complaint  # 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_complaint_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of the complaint (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(Complaint, 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_complaint" % 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_complaint`")  # 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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/bounce/complaints/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Complaint',  # 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_complaints(self, **kwargs):  # noqa: E501
        """Get paginated list of complaints.  # noqa: E501

        SMTP complaints made against your account  # 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_complaints(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index 
        :param int size: Optional page size 
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageComplaint
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_complaints_with_http_info(**kwargs)  # noqa: E501

    def get_complaints_with_http_info(self, **kwargs):  # noqa: E501
        """Get paginated list of complaints.  # noqa: E501

        SMTP complaints made against your account  # 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_complaints_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index 
        :param int size: Optional page size 
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PageComplaint, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            '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 get_complaints" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        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_complaints`, must be a value less than or equal to `100`")  # 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 '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(
            '/bounce/complaints', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageComplaint',  # 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_list_unsubscribe_recipients(self, **kwargs):  # noqa: E501
        """Get paginated list of unsubscribed recipients.  # noqa: E501

        Unsubscribed recipient have unsubscribed from a mailing list for a user or domain and cannot be contacted again.  # 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_list_unsubscribe_recipients(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index
        :param int size: Optional page size 
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param str domain_id: Filter by domainId
        :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: PageListUnsubscribeRecipients
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_list_unsubscribe_recipients_with_http_info(**kwargs)  # noqa: E501

    def get_list_unsubscribe_recipients_with_http_info(self, **kwargs):  # noqa: E501
        """Get paginated list of unsubscribed recipients.  # noqa: E501

        Unsubscribed recipient have unsubscribed from a mailing list for a user or domain and cannot be contacted again.  # 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_list_unsubscribe_recipients_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index
        :param int size: Optional page size 
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param str domain_id: Filter by domainId
        :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(PageListUnsubscribeRecipients, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            'domain_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_list_unsubscribe_recipients" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        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_list_unsubscribe_recipients`, must be a value less than or equal to `100`")  # 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 'domain_id' in local_var_params and local_var_params['domain_id'] is not None:  # noqa: E501
            query_params.append(('domainId', local_var_params['domain_id']))  # 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(
            '/bounce/list-unsubscribe-recipients', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageListUnsubscribeRecipients',  # 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)

mailslurp_client/api/attachment_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class AttachmentControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def delete_all_attachments(self, **kwargs):  # noqa: E501
        """Delete all attachments  # 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_all_attachments(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_all_attachments_with_http_info(**kwargs)  # noqa: E501

    def delete_all_attachments_with_http_info(self, **kwargs):  # noqa: E501
        """Delete all attachments  # 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_all_attachments_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: None
                 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 delete_all_attachments" % 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
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/attachments', '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 delete_attachment(self, attachment_id, **kwargs):  # noqa: E501
        """Delete an attachment  # 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_attachment(attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str attachment_id: ID of attachment (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_attachment_with_http_info(attachment_id, **kwargs)  # noqa: E501

    def delete_attachment_with_http_info(self, attachment_id, **kwargs):  # noqa: E501
        """Delete an attachment  # 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_attachment_with_http_info(attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str attachment_id: ID of attachment (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 = [
            'attachment_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_attachment" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'attachment_id' is set
        if self.api_client.client_side_validation and ('attachment_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['attachment_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `attachment_id` when calling `delete_attachment`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'attachment_id' in local_var_params:
            path_params['attachmentId'] = local_var_params['attachment_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(
            '/attachments/{attachmentId}', '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 download_attachment_as_base64_encoded(self, attachment_id, **kwargs):  # noqa: E501
        """Get email attachment as base64 encoded string as alternative to binary responses. To read the content decode the Base64 encoded contents.  # noqa: E501

        Returns the specified attachment for a given email as a base 64 encoded string. The response type is application/json. This method is similar to the `downloadAttachment` method but allows some clients to get around issues with binary responses.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.download_attachment_as_base64_encoded(attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str attachment_id: ID of attachment (required)
        :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: DownloadAttachmentDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.download_attachment_as_base64_encoded_with_http_info(attachment_id, **kwargs)  # noqa: E501

    def download_attachment_as_base64_encoded_with_http_info(self, attachment_id, **kwargs):  # noqa: E501
        """Get email attachment as base64 encoded string as alternative to binary responses. To read the content decode the Base64 encoded contents.  # noqa: E501

        Returns the specified attachment for a given email as a base 64 encoded string. The response type is application/json. This method is similar to the `downloadAttachment` method but allows some clients to get around issues with binary responses.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.download_attachment_as_base64_encoded_with_http_info(attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str attachment_id: ID of attachment (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(DownloadAttachmentDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'attachment_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 download_attachment_as_base64_encoded" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'attachment_id' is set
        if self.api_client.client_side_validation and ('attachment_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['attachment_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `attachment_id` when calling `download_attachment_as_base64_encoded`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'attachment_id' in local_var_params:
            path_params['attachmentId'] = local_var_params['attachment_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/attachments/{attachmentId}/base64', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DownloadAttachmentDto',  # 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 download_attachment_as_bytes(self, attachment_id, **kwargs):  # noqa: E501
        """Download attachments. Get email attachment bytes. If you have trouble with byte responses try the `downloadAttachmentBase64` response endpoints.  # noqa: E501

        Returns the specified attachment for a given email as a stream / array of bytes. You can find attachment ids in email responses endpoint responses. The response type is application/octet-stream.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.download_attachment_as_bytes(attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str attachment_id: ID of attachment (required)
        :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: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.download_attachment_as_bytes_with_http_info(attachment_id, **kwargs)  # noqa: E501

    def download_attachment_as_bytes_with_http_info(self, attachment_id, **kwargs):  # noqa: E501
        """Download attachments. Get email attachment bytes. If you have trouble with byte responses try the `downloadAttachmentBase64` response endpoints.  # noqa: E501

        Returns the specified attachment for a given email as a stream / array of bytes. You can find attachment ids in email responses endpoint responses. The response type is application/octet-stream.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.download_attachment_as_bytes_with_http_info(attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str attachment_id: ID of attachment (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(str, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'attachment_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 download_attachment_as_bytes" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'attachment_id' is set
        if self.api_client.client_side_validation and ('attachment_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['attachment_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `attachment_id` when calling `download_attachment_as_bytes`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'attachment_id' in local_var_params:
            path_params['attachmentId'] = local_var_params['attachment_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/octet-stream'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/attachments/{attachmentId}/bytes', 'GET',
            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_attachment(self, attachment_id, **kwargs):  # noqa: E501
        """Get an attachment entity  # 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_attachment(attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str attachment_id: ID of attachment (required)
        :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: AttachmentEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_attachment_with_http_info(attachment_id, **kwargs)  # noqa: E501

    def get_attachment_with_http_info(self, attachment_id, **kwargs):  # noqa: E501
        """Get an attachment entity  # 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_attachment_with_http_info(attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str attachment_id: ID of attachment (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(AttachmentEntity, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'attachment_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_attachment" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'attachment_id' is set
        if self.api_client.client_side_validation and ('attachment_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['attachment_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `attachment_id` when calling `get_attachment`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'attachment_id' in local_var_params:
            path_params['attachmentId'] = local_var_params['attachment_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/attachments/{attachmentId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AttachmentEntity',  # 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_attachment_info(self, attachment_id, **kwargs):  # noqa: E501
        """Get email attachment metadata information  # noqa: E501

        Returns the metadata for an attachment. It is saved separately to the content of the attachment. Contains properties `name` and `content-type` and `content-length` in bytes for a given attachment.  # 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_attachment_info(attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str attachment_id: ID of attachment (required)
        :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: AttachmentMetaData
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_attachment_info_with_http_info(attachment_id, **kwargs)  # noqa: E501

    def get_attachment_info_with_http_info(self, attachment_id, **kwargs):  # noqa: E501
        """Get email attachment metadata information  # noqa: E501

        Returns the metadata for an attachment. It is saved separately to the content of the attachment. Contains properties `name` and `content-type` and `content-length` in bytes for a given attachment.  # 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_attachment_info_with_http_info(attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str attachment_id: ID of attachment (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(AttachmentMetaData, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'attachment_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_attachment_info" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'attachment_id' is set
        if self.api_client.client_side_validation and ('attachment_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['attachment_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `attachment_id` when calling `get_attachment_info`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'attachment_id' in local_var_params:
            path_params['attachmentId'] = local_var_params['attachment_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/attachments/{attachmentId}/metadata', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AttachmentMetaData',  # 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_attachments(self, **kwargs):  # noqa: E501
        """Get email attachments  # noqa: E501

        Get all attachments in paginated response. Each entity contains meta data for the attachment such as `name` and `content-type`. Use the `attachmentId` and the download endpoints to get the file contents.  # 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_attachments(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index for list pagination
        :param int size: Optional page size for list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param str file_name_filter: Optional file name and content type 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 str inbox_id: Optional inboxId to filter attachments by
        :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: PageAttachmentEntity
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_attachments_with_http_info(**kwargs)  # noqa: E501

    def get_attachments_with_http_info(self, **kwargs):  # noqa: E501
        """Get email attachments  # noqa: E501

        Get all attachments in paginated response. Each entity contains meta data for the attachment such as `name` and `content-type`. Use the `attachmentId` and the download endpoints to get the file contents.  # 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_attachments_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index for list pagination
        :param int size: Optional page size for list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param str file_name_filter: Optional file name and content type 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 str inbox_id: Optional inboxId to filter attachments by
        :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(PageAttachmentEntity, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            'file_name_filter',
            'since',
            'before',
            '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 get_attachments" % 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
        if 'file_name_filter' in local_var_params and local_var_params['file_name_filter'] is not None:  # noqa: E501
            query_params.append(('fileNameFilter', local_var_params['file_name_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 '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
        # 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(
            '/attachments', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageAttachmentEntity',  # 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 upload_attachment(self, upload_attachment_options, **kwargs):  # noqa: E501
        """Upload an attachment for sending using base64 file encoding. Returns an array whose first element is the ID of the uploaded attachment.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upload_attachment(upload_attachment_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UploadAttachmentOptions upload_attachment_options: (required)
        :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: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.upload_attachment_with_http_info(upload_attachment_options, **kwargs)  # noqa: E501

    def upload_attachment_with_http_info(self, upload_attachment_options, **kwargs):  # noqa: E501
        """Upload an attachment for sending using base64 file encoding. Returns an array whose first element is the ID of the uploaded attachment.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upload_attachment_with_http_info(upload_attachment_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UploadAttachmentOptions upload_attachment_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(list[str], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'upload_attachment_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 upload_attachment" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'upload_attachment_options' is set
        if self.api_client.client_side_validation and ('upload_attachment_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['upload_attachment_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `upload_attachment_options` when calling `upload_attachment`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'upload_attachment_options' in local_var_params:
            body_params = local_var_params['upload_attachment_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(
            '/attachments', 'POST',
            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 upload_attachment_bytes(self, **kwargs):  # noqa: E501
        """Upload an attachment for sending using file byte stream input octet stream. Returns an array whose first element is the ID of the uploaded attachment.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upload_attachment_bytes(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str content_type:
        :param str content_type2: Optional contentType for file. For instance `application/pdf`
        :param str content_id: Optional content ID (CID) to save upload with
        :param str filename: Optional filename to save upload with
        :param str filename2:
        :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: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.upload_attachment_bytes_with_http_info(**kwargs)  # noqa: E501

    def upload_attachment_bytes_with_http_info(self, **kwargs):  # noqa: E501
        """Upload an attachment for sending using file byte stream input octet stream. Returns an array whose first element is the ID of the uploaded attachment.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upload_attachment_bytes_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str content_type:
        :param str content_type2: Optional contentType for file. For instance `application/pdf`
        :param str content_id: Optional content ID (CID) to save upload with
        :param str filename: Optional filename to save upload with
        :param str filename2:
        :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 = [
            'content_type',
            'content_type2',
            'content_id',
            'filename',
            'filename2'
        ]
        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 upload_attachment_bytes" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'content_type2' in local_var_params and local_var_params['content_type2'] is not None:  # noqa: E501
            query_params.append(('contentType', local_var_params['content_type2']))  # noqa: E501
        if 'content_id' in local_var_params and local_var_params['content_id'] is not None:  # noqa: E501
            query_params.append(('contentId', local_var_params['content_id']))  # noqa: E501
        if 'filename' in local_var_params and local_var_params['filename'] is not None:  # noqa: E501
            query_params.append(('filename', local_var_params['filename']))  # noqa: E501

        header_params = {}
        if 'content_type' in local_var_params:
            header_params['contentType'] = local_var_params['content_type']  # noqa: E501
        if 'filename2' in local_var_params:
            header_params['filename'] = local_var_params['filename2']  # noqa: E501

        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(
            '/attachments/bytes', 'POST',
            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 upload_multipart_form(self, **kwargs):  # noqa: E501
        """Upload an attachment for sending using a Multipart Form request. Returns an array whose first element is the ID of the uploaded attachment.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upload_multipart_form(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str content_id: Optional content ID of attachment
        :param str content_type: Optional content type of attachment
        :param str filename: Optional name of file
        :param str x_filename: Optional content type header of attachment
        :param InlineObject inline_object:
        :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: list[str]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.upload_multipart_form_with_http_info(**kwargs)  # noqa: E501

    def upload_multipart_form_with_http_info(self, **kwargs):  # noqa: E501
        """Upload an attachment for sending using a Multipart Form request. Returns an array whose first element is the ID of the uploaded attachment.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.upload_multipart_form_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str content_id: Optional content ID of attachment
        :param str content_type: Optional content type of attachment
        :param str filename: Optional name of file
        :param str x_filename: Optional content type header of attachment
        :param InlineObject inline_object:
        :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 = [
            'content_id',
            'content_type',
            'filename',
            'x_filename',
            'inline_object'
        ]
        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 upload_multipart_form" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'content_id' in local_var_params and local_var_params['content_id'] is not None:  # noqa: E501
            query_params.append(('contentId', local_var_params['content_id']))  # noqa: E501
        if 'content_type' in local_var_params and local_var_params['content_type'] is not None:  # noqa: E501
            query_params.append(('contentType', local_var_params['content_type']))  # noqa: E501
        if 'filename' in local_var_params and local_var_params['filename'] is not None:  # noqa: E501
            query_params.append(('filename', local_var_params['filename']))  # noqa: E501
        if 'x_filename' in local_var_params and local_var_params['x_filename'] is not None:  # noqa: E501
            query_params.append(('x-filename', local_var_params['x_filename']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'inline_object' in local_var_params:
            body_params = local_var_params['inline_object']
        # 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(
            '/attachments/multipart', 'POST',
            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)

mailslurp_client/api/alias_controller_api.py

# coding: utf-8

"""
    MailSlurp API

    MailSlurp is an API for sending and receiving emails from dynamically allocated email addresses. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more.  ## Resources  - [Homepage](https://www.mailslurp.com) - Get an [API KEY](https://app.mailslurp.com/sign-up/) - Generated [SDK Clients](https://docs.mailslurp.com/) - [Examples](https://github.com/mailslurp/examples) repository  # noqa: E501

    The version of the OpenAPI document: 6.5.2
    Contact: contact@mailslurp.dev
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from mailslurp_client.api_client import ApiClient
from mailslurp_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class AliasControllerApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

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

    def create_alias(self, create_alias_options, **kwargs):  # noqa: E501
        """Create an email alias. Must be verified by clicking link inside verification email that will be sent to the address. Once verified the alias will be active.  # noqa: E501

        Email aliases use a MailSlurp randomly generated email address (or a custom domain inbox that you provide) to mask or proxy a real email address. Emails sent to the alias address will be forwarded to the hidden email address it was created for. If you want to send a reply use the threadId attached  # 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_alias(create_alias_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateAliasOptions create_alias_options: (required)
        :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: AliasDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_alias_with_http_info(create_alias_options, **kwargs)  # noqa: E501

    def create_alias_with_http_info(self, create_alias_options, **kwargs):  # noqa: E501
        """Create an email alias. Must be verified by clicking link inside verification email that will be sent to the address. Once verified the alias will be active.  # noqa: E501

        Email aliases use a MailSlurp randomly generated email address (or a custom domain inbox that you provide) to mask or proxy a real email address. Emails sent to the alias address will be forwarded to the hidden email address it was created for. If you want to send a reply use the threadId attached  # 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_alias_with_http_info(create_alias_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateAliasOptions create_alias_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(AliasDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_alias_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_alias" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'create_alias_options' is set
        if self.api_client.client_side_validation and ('create_alias_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_alias_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_alias_options` when calling `create_alias`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_alias_options' in local_var_params:
            body_params = local_var_params['create_alias_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(
            '/aliases', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AliasDto',  # 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_alias(self, alias_id, **kwargs):  # noqa: E501
        """Delete an email alias  # 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_alias(alias_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str alias_id: (required)
        :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.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_alias_with_http_info(alias_id, **kwargs)  # noqa: E501

    def delete_alias_with_http_info(self, alias_id, **kwargs):  # noqa: E501
        """Delete an email alias  # 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_alias_with_http_info(alias_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str alias_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 = [
            'alias_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_alias" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'alias_id' is set
        if self.api_client.client_side_validation and ('alias_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['alias_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `alias_id` when calling `delete_alias`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'alias_id' in local_var_params:
            path_params['aliasId'] = local_var_params['alias_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(
            '/aliases/{aliasId}', '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_alias(self, alias_id, **kwargs):  # noqa: E501
        """Get an email alias  # noqa: E501

        Get an email alias by ID  # 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_alias(alias_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str alias_id: (required)
        :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: AliasDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_alias_with_http_info(alias_id, **kwargs)  # noqa: E501

    def get_alias_with_http_info(self, alias_id, **kwargs):  # noqa: E501
        """Get an email alias  # noqa: E501

        Get an email alias by ID  # 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_alias_with_http_info(alias_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str alias_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: tuple(AliasDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'alias_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_alias" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'alias_id' is set
        if self.api_client.client_side_validation and ('alias_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['alias_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `alias_id` when calling `get_alias`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'alias_id' in local_var_params:
            path_params['aliasId'] = local_var_params['alias_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/aliases/{aliasId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AliasDto',  # 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_alias_emails(self, alias_id, **kwargs):  # noqa: E501
        """Get emails for an alias  # noqa: E501

        Get paginated emails for an alias by ID  # 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_alias_emails(alias_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str alias_id: (required)
        :param int page: Optional page index alias email list pagination
        :param int size: Optional page size alias email list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Optional filter by sent after given date time
        :param datetime before: Optional filter by sent before given date time
        :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: PageEmailProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_alias_emails_with_http_info(alias_id, **kwargs)  # noqa: E501

    def get_alias_emails_with_http_info(self, alias_id, **kwargs):  # noqa: E501
        """Get emails for an alias  # noqa: E501

        Get paginated emails for an alias by ID  # 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_alias_emails_with_http_info(alias_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str alias_id: (required)
        :param int page: Optional page index alias email list pagination
        :param int size: Optional page size alias email list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Optional filter by sent after given date time
        :param datetime before: Optional filter by sent before given date 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(PageEmailProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'alias_id',
            'page',
            'size',
            'sort',
            '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 get_alias_emails" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'alias_id' is set
        if self.api_client.client_side_validation and ('alias_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['alias_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `alias_id` when calling `get_alias_emails`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'alias_id' in local_var_params:
            path_params['aliasId'] = local_var_params['alias_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
        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(
            '/aliases/{aliasId}/emails', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageEmailProjection',  # 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_alias_threads(self, alias_id, **kwargs):  # noqa: E501
        """Get threads created for an alias  # noqa: E501

        Returns threads created for an email alias in paginated form  # 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_alias_threads(alias_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str alias_id: (required)
        :param int page: Optional page index in thread list pagination
        :param int size: Optional page size in thread list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Optional filter by sent after given date time
        :param datetime before: Optional filter by sent before given date time
        :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: PageThreadProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_alias_threads_with_http_info(alias_id, **kwargs)  # noqa: E501

    def get_alias_threads_with_http_info(self, alias_id, **kwargs):  # noqa: E501
        """Get threads created for an alias  # noqa: E501

        Returns threads created for an email alias in paginated form  # 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_alias_threads_with_http_info(alias_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str alias_id: (required)
        :param int page: Optional page index in thread list pagination
        :param int size: Optional page size in thread list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Optional filter by sent after given date time
        :param datetime before: Optional filter by sent before given date 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(PageThreadProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'alias_id',
            'page',
            'size',
            'sort',
            '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 get_alias_threads" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'alias_id' is set
        if self.api_client.client_side_validation and ('alias_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['alias_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `alias_id` when calling `get_alias_threads`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'alias_id' in local_var_params:
            path_params['aliasId'] = local_var_params['alias_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
        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(
            '/aliases/{aliasId}/threads', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageThreadProjection',  # 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_aliases(self, **kwargs):  # noqa: E501
        """Get all email aliases you have created  # noqa: E501

        Get all email aliases in paginated form  # 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_aliases(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str search: Optional search term
        :param int page: Optional page index in alias list pagination
        :param int size: Optional page size in alias list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Filter by created at after the given timestamp
        :param datetime before: Filter by created at before the given timestamp
        :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: PageAlias
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_aliases_with_http_info(**kwargs)  # noqa: E501

    def get_aliases_with_http_info(self, **kwargs):  # noqa: E501
        """Get all email aliases you have created  # noqa: E501

        Get all email aliases in paginated form  # 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_aliases_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str search: Optional search term
        :param int page: Optional page index in alias list pagination
        :param int size: Optional page size in alias list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :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(PageAlias, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'search',
            'page',
            'size',
            'sort',
            '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 get_aliases" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'search' in local_var_params and local_var_params['search'] is not None:  # noqa: E501
            query_params.append(('search', local_var_params['search']))  # 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 '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 '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(
            '/aliases', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageAlias',  # 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_thread(self, thread_id, **kwargs):  # noqa: E501
        """Get a thread  # noqa: E501

        Return a thread associated with an alias  # 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_thread(thread_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str thread_id: (required)
        :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: ThreadProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_thread_with_http_info(thread_id, **kwargs)  # noqa: E501

    def get_thread_with_http_info(self, thread_id, **kwargs):  # noqa: E501
        """Get a thread  # noqa: E501

        Return a thread associated with an alias  # 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_thread_with_http_info(thread_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str thread_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: tuple(ThreadProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'thread_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_thread" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'thread_id' is set
        if self.api_client.client_side_validation and ('thread_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['thread_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `thread_id` when calling `get_thread`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'thread_id' in local_var_params:
            path_params['threadId'] = local_var_params['thread_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(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/aliases/threads/{threadId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ThreadProjection',  # 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_threads_paginated(self, **kwargs):  # noqa: E501
        """Get all threads  # noqa: E501

        Returns threads created for all aliases in paginated form  # 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_threads_paginated(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index in thread list pagination
        :param int size: Optional page size in thread list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Optional filter by sent after given date time
        :param datetime before: Optional filter by sent before given date time
        :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: PageThreadProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_threads_paginated_with_http_info(**kwargs)  # noqa: E501

    def get_threads_paginated_with_http_info(self, **kwargs):  # noqa: E501
        """Get all threads  # noqa: E501

        Returns threads created for all aliases in paginated form  # 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_threads_paginated_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index in thread list pagination
        :param int size: Optional page size in thread list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Optional filter by sent after given date time
        :param datetime before: Optional filter by sent before given date 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(PageThreadProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            '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 get_threads_paginated" % 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
        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(
            '/aliases/threads', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageThreadProjection',  # 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 reply_to_alias_email(self, alias_id, email_id, reply_to_alias_email_options, **kwargs):  # noqa: E501
        """Reply to an email  # noqa: E501

        Send the reply to the email sender or reply-to and include same subject cc bcc etc. Reply to an email and the contents will be sent with the existing subject to the emails `to`, `cc`, and `bcc`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.reply_to_alias_email(alias_id, email_id, reply_to_alias_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str alias_id: ID of the alias that email belongs to (required)
        :param str email_id: ID of the email that should be replied to (required)
        :param ReplyToAliasEmailOptions reply_to_alias_email_options: (required)
        :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: SentEmailDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.reply_to_alias_email_with_http_info(alias_id, email_id, reply_to_alias_email_options, **kwargs)  # noqa: E501

    def reply_to_alias_email_with_http_info(self, alias_id, email_id, reply_to_alias_email_options, **kwargs):  # noqa: E501
        """Reply to an email  # noqa: E501

        Send the reply to the email sender or reply-to and include same subject cc bcc etc. Reply to an email and the contents will be sent with the existing subject to the emails `to`, `cc`, and `bcc`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.reply_to_alias_email_with_http_info(alias_id, email_id, reply_to_alias_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str alias_id: ID of the alias that email belongs to (required)
        :param str email_id: ID of the email that should be replied to (required)
        :param ReplyToAliasEmailOptions reply_to_alias_email_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(SentEmailDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'alias_id',
            'email_id',
            'reply_to_alias_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 reply_to_alias_email" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'alias_id' is set
        if self.api_client.client_side_validation and ('alias_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['alias_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `alias_id` when calling `reply_to_alias_email`")  # noqa: E501
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `reply_to_alias_email`")  # noqa: E501
        # verify the required parameter 'reply_to_alias_email_options' is set
        if self.api_client.client_side_validation and ('reply_to_alias_email_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['reply_to_alias_email_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `reply_to_alias_email_options` when calling `reply_to_alias_email`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'alias_id' in local_var_params:
            path_params['aliasId'] = local_var_params['alias_id']  # noqa: E501
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'reply_to_alias_email_options' in local_var_params:
            body_params = local_var_params['reply_to_alias_email_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(
            '/aliases/{aliasId}/emails/{emailId}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SentEmailDto',  # 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 send_alias_email(self, alias_id, send_email_options, **kwargs):  # noqa: E501
        """Send an email from an alias inbox  # noqa: E501

        Send an email from an alias. Replies to the email will be forwarded to the alias masked email address  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.send_alias_email(alias_id, send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str alias_id: (required)
        :param SendEmailOptions send_email_options: (required)
        :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: SentEmailDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.send_alias_email_with_http_info(alias_id, send_email_options, **kwargs)  # noqa: E501

    def send_alias_email_with_http_info(self, alias_id, send_email_options, **kwargs):  # noqa: E501
        """Send an email from an alias inbox  # noqa: E501

        Send an email from an alias. Replies to the email will be forwarded to the alias masked email address  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.send_alias_email_with_http_info(alias_id, send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str alias_id: (required)
        :param SendEmailOptions send_email_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(SentEmailDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'alias_id',
            '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 send_alias_email" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'alias_id' is set
        if self.api_client.client_side_validation and ('alias_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['alias_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `alias_id` when calling `send_alias_email`")  # noqa: E501
        # verify the required parameter 'send_email_options' is set
        if self.api_client.client_side_validation and ('send_email_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['send_email_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `send_email_options` when calling `send_alias_email`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'alias_id' in local_var_params:
            path_params['aliasId'] = local_var_params['alias_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'send_email_options' in local_var_params:
            body_params = local_var_params['send_email_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(
            '/aliases/{aliasId}/emails', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SentEmailDto',  # 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_alias(self, alias_id, update_alias_options, **kwargs):  # noqa: E501
        """Update an email alias  # 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_alias(alias_id, update_alias_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str alias_id: (required)
        :param UpdateAliasOptions update_alias_options: (required)
        :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: AliasDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_alias_with_http_info(alias_id, update_alias_options, **kwargs)  # noqa: E501

    def update_alias_with_http_info(self, alias_id, update_alias_options, **kwargs):  # noqa: E501
        """Update an email alias  # 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_alias_with_http_info(alias_id, update_alias_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str alias_id: (required)
        :param UpdateAliasOptions update_alias_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(AliasDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'alias_id',
            'update_alias_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_alias" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'alias_id' is set
        if self.api_client.client_side_validation and ('alias_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['alias_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `alias_id` when calling `update_alias`")  # noqa: E501
        # verify the required parameter 'update_alias_options' is set
        if self.api_client.client_side_validation and ('update_alias_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['update_alias_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `update_alias_options` when calling `update_alias`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'alias_id' in local_var_params:
            path_params['aliasId'] = local_var_params['alias_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'update_alias_options' in local_var_params:
            body_params = local_var_params['update_alias_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(
            '/aliases/{aliasId}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AliasDto',  # 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)

mailslurp_client/api/__init__.py

from __future__ import absolute_import

# flake8: noqa

# import apis into api package
from mailslurp_client.api.alias_controller_api import AliasControllerApi
from mailslurp_client.api.attachment_controller_api import AttachmentControllerApi
from mailslurp_client.api.bounce_controller_api import BounceControllerApi
from mailslurp_client.api.bulk_actions_controller_api import BulkActionsControllerApi
from mailslurp_client.api.common_actions_controller_api import CommonActionsControllerApi
from mailslurp_client.api.connector_controller_api import ConnectorControllerApi
from mailslurp_client.api.contact_controller_api import ContactControllerApi
from mailslurp_client.api.domain_controller_api import DomainControllerApi
from mailslurp_client.api.email_controller_api import EmailControllerApi
from mailslurp_client.api.email_verification_controller_api import EmailVerificationControllerApi
from mailslurp_client.api.expired_controller_api import ExpiredControllerApi
from mailslurp_client.api.export_controller_api import ExportControllerApi
from mailslurp_client.api.form_controller_api import FormControllerApi
from mailslurp_client.api.group_controller_api import GroupControllerApi
from mailslurp_client.api.imap_controller_api import ImapControllerApi
from mailslurp_client.api.inbox_controller_api import InboxControllerApi
from mailslurp_client.api.inbox_forwarder_controller_api import InboxForwarderControllerApi
from mailslurp_client.api.inbox_replier_controller_api import InboxReplierControllerApi
from mailslurp_client.api.inbox_ruleset_controller_api import InboxRulesetControllerApi
from mailslurp_client.api.mail_server_controller_api import MailServerControllerApi
from mailslurp_client.api.missed_email_controller_api import MissedEmailControllerApi
from mailslurp_client.api.phone_controller_api import PhoneControllerApi
from mailslurp_client.api.sent_emails_controller_api import SentEmailsControllerApi
from mailslurp_client.api.sms_controller_api import SmsControllerApi
from mailslurp_client.api.template_controller_api import TemplateControllerApi
from mailslurp_client.api.tools_controller_api import ToolsControllerApi
from mailslurp_client.api.tracking_controller_api import TrackingControllerApi
from mailslurp_client.api.user_controller_api import UserControllerApi
from mailslurp_client.api.wait_for_controller_api import WaitForControllerApi
from mailslurp_client.api.webhook_controller_api import WebhookControllerApi