"""
    Stencila Hub API

    ## Authentication  Many endpoints in the Stencila Hub API require an authentication token. These tokens carry many privileges, so be sure to keep them secure. Do not place your tokens in publicly accessible areas such as client-side code. The API is only served over HTTPS to avoid exposing tokens and other data on the network.  To obtain a token, [`POST /api/tokens`](#operations-tokens-tokens_create) with either a `username` and `password` pair, or an [OpenID Connect](https://openid.net/connect/) token. Then use the token in the `Authorization` header of subsequent requests with the prefix `Token` e.g.      curl -H \"Authorization: Token 48866b1e38a2e9db0baada2140b2327937f4a3636dd5f2dfd8c212341c88d34\" https://hub.stenci.la/api/projects/  Alternatively, you can use `Basic` authentication with the token used as the username and no password. This can be more convenient when using command line tools such as [cURL](https://curl.haxx.se/) e.g.      curl -u 48866b1e38a2e9db0baada2140b2327937f4a3636dd5f2dfd8c212341c88d34: https://hub.stenci.la/api/projects/  Or, the less ubiquitous, but more accessible [httpie](https://httpie.org/):      http --auth 48866b1e38a2e9db0baada2140b2327937f4a3636dd5f2dfd8c212341c88d34: https://hub.stenci.la/api/projects/  In both examples above, the trailing colon is not required but avoids being asked for a password.  ## Versioning  The Stencila Hub is released using semantic versioning. The current version is available from the [`GET /api/status`](/api/status) endpoint. Please see the [Github release page](https://github.com/stencila/hub/releases) and the [changelog](https://github.com/stencila/hub/blob/master/CHANGELOG.md) for details on each release. We currently do not provide versioning of the API but plan to do so soon (probably by using a `Accept: application/vnd.stencila.hub+json;version=1.0` request header). If you are using, or interested in using, the API please contact us and we may be able to expedite this.   # noqa: E501

    The version of the OpenAPI document: v1
    Contact: hello@stenci.la
    Generated by: https://openapi-generator.tech
"""


import re  # noqa: F401
import sys  # noqa: F401

from stencila.hub.api_client import ApiClient, Endpoint as _Endpoint
from stencila.hub.model_utils import (  # noqa: F401
    check_allowed_values,
    check_validations,
    date,
    datetime,
    file_type,
    none_type,
    validate_and_convert_types
)
from stencila.hub.model.account_create import AccountCreate
from stencila.hub.model.account_retrieve import AccountRetrieve
from stencila.hub.model.account_team import AccountTeam
from stencila.hub.model.account_team_create import AccountTeamCreate
from stencila.hub.model.account_team_update import AccountTeamUpdate
from stencila.hub.model.account_update import AccountUpdate
from stencila.hub.model.account_user import AccountUser
from stencila.hub.model.account_user_create import AccountUserCreate
from stencila.hub.model.account_user_patch import AccountUserPatch
from stencila.hub.model.inline_response200 import InlineResponse200
from stencila.hub.model.inline_response2001 import InlineResponse2001
from stencila.hub.model.inline_response2002 import InlineResponse2002
from stencila.hub.model.inline_response2003 import InlineResponse2003
from stencila.hub.model.inline_response2004 import InlineResponse2004
from stencila.hub.model.inline_response2005 import InlineResponse2005
from stencila.hub.model.inline_response2006 import InlineResponse2006
from stencila.hub.model.queue import Queue
from stencila.hub.model.user_identifier import UserIdentifier
from stencila.hub.model.worker import Worker
from stencila.hub.model.zone import Zone
from stencila.hub.model.zone_create import ZoneCreate


class AccountsApi(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 __accounts_broker_list(
            self,
            account,
            **kwargs
        ):
            """Connect to the job broker for the account.  # noqa: E501

            This endpoint is for self-hosted workers. These need to be enabled for the account.  You may need to include your authentication token in the URL. For example, when using [Celery](https://www.celeryproject.org/) in Python:  ```python app = Celery(     broker=\"https://{token}@hub.stenci.la/api/accounts/{account}/jobs/broker\".format(         token = os.environ.get(\"STENCILA_TOKEN\"),         account = os.environ.get(\"STENCILA_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.accounts_broker_list(account, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):

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

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

        self.accounts_broker_list = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/broker',
                'operation_id': 'accounts_broker_list',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                ],
                'required': [
                    'account',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                },
                'attribute_map': {
                    'account': 'account',
                },
                'location_map': {
                    'account': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_broker_list
        )

        def __accounts_create(
            self,
            data,
            **kwargs
        ):
            """Create an account.  # noqa: E501

            Receives details of the account. Returns details of the new 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.accounts_create(data, async_req=True)
            >>> result = thread.get()

            Args:
                data (AccountCreate):

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

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

        self.accounts_create = _Endpoint(
            settings={
                'response_type': (AccountCreate,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/',
                'operation_id': 'accounts_create',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'data',
                ],
                'required': [
                    'data',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'data':
                        (AccountCreate,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'data': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__accounts_create
        )

        def __accounts_list(
            self,
            **kwargs
        ):
            """List accounts.  # noqa: E501

            The returned list can be filtered using query parameters, `is`, `role`, and `search`.  The `role` filter applies to the currently authenticated user, and as such has no effected for unauthenticated requests. When `role=member` will return all accounts that the user is a `member`, `manager`, or `owner` of. When `role=manager` will return all accounts that the user is a `manager` or `owner` of.  For example, to list all organizational accounts for which the authenticated user is a member of (and therefore can create a project for):      GET /accounts?is=org&role=member  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

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


            Keyword Args:
                limit (int): Number of results to return per page.. [optional]
                offset (int): The initial index from which to return the results.. [optional]
                _is (str): Whether or the account is for an organization or user.. [optional]
                role (str): The role that the currently authenticated user has for the account e.g. \"member\", \"manager\", or \"owner\". [optional]
                search (str): A string to search for in the account `name` or `displayName`.. [optional]
                _return_http_data_only (bool): response data without head status
                    code and headers. Default is True.
                _preload_content (bool): if False, the urllib3.HTTPResponse object
                    will be returned without reading/decoding response data.
                    Default is True.
                _request_timeout (float/tuple): timeout setting for this request. If one
                    number provided, it will be total request timeout. It can also
                    be a pair (tuple) of (connection, read) timeouts.
                    Default is None.
                _check_input_type (bool): specifies if type checking
                    should be done one the data sent to the server.
                    Default is True.
                _check_return_type (bool): specifies if type checking
                    should be done one the data received from the server.
                    Default is True.
                _host_index (int/None): specifies the index of the server
                    that we want to use.
                    Default is read from the configuration.
                async_req (bool): execute request asynchronously

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

        self.accounts_list = _Endpoint(
            settings={
                'response_type': (InlineResponse200,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/',
                'operation_id': 'accounts_list',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'limit',
                    'offset',
                    '_is',
                    'role',
                    'search',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                    '_is',
                    'role',
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                    ('_is',): {

                        "USER": "user",
                        "ORG": "org"
                    },
                    ('role',): {

                        "MEMBER": "member",
                        "MANAGER": "manager",
                        "OWNER": "owner"
                    },
                },
                'openapi_types': {
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                    '_is':
                        (str,),
                    'role':
                        (str,),
                    'search':
                        (str,),
                },
                'attribute_map': {
                    'limit': 'limit',
                    'offset': 'offset',
                    '_is': 'is',
                    'role': 'role',
                    'search': 'search',
                },
                'location_map': {
                    'limit': 'query',
                    'offset': 'query',
                    '_is': 'query',
                    'role': 'query',
                    'search': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_list
        )

        def __accounts_partial_update(
            self,
            account,
            data,
            **kwargs
        ):
            """Update an account.  # noqa: E501

            Receives details of the account. Returns updated details of the 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.accounts_partial_update(account, data, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                data (AccountUpdate):

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

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

        self.accounts_partial_update = _Endpoint(
            settings={
                'response_type': (AccountUpdate,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/',
                'operation_id': 'accounts_partial_update',
                'http_method': 'PATCH',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'data',
                ],
                'required': [
                    'account',
                    'data',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'data':
                        (AccountUpdate,),
                },
                'attribute_map': {
                    'account': 'account',
                },
                'location_map': {
                    'account': 'path',
                    'data': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__accounts_partial_update
        )

        def __accounts_queues_list(
            self,
            account,
            **kwargs
        ):
            """List objects.  # noqa: E501

            Returns a list of objects.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.accounts_queues_list(account, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):

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

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

        self.accounts_queues_list = _Endpoint(
            settings={
                'response_type': (InlineResponse2001,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/queues/',
                'operation_id': 'accounts_queues_list',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'limit',
                    'offset',
                ],
                'required': [
                    'account',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'account': 'account',
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'account': 'path',
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_queues_list
        )

        def __accounts_queues_read(
            self,
            account,
            queue,
            **kwargs
        ):
            """Retrieve an object.  # noqa: E501

            Returns data for the object.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.accounts_queues_read(account, queue, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                queue (str):

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

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

        self.accounts_queues_read = _Endpoint(
            settings={
                'response_type': (Queue,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/queues/{queue}/',
                'operation_id': 'accounts_queues_read',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'queue',
                ],
                'required': [
                    'account',
                    'queue',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'queue':
                        (str,),
                },
                'attribute_map': {
                    'account': 'account',
                    'queue': 'queue',
                },
                'location_map': {
                    'account': 'path',
                    'queue': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_queues_read
        )

        def __accounts_read(
            self,
            account,
            **kwargs
        ):
            """Retrieve an account.  # noqa: E501

            Returns details of the 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.accounts_read(account, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):

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

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

        self.accounts_read = _Endpoint(
            settings={
                'response_type': (AccountRetrieve,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/',
                'operation_id': 'accounts_read',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                ],
                'required': [
                    'account',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                },
                'attribute_map': {
                    'account': 'account',
                },
                'location_map': {
                    'account': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_read
        )

        def __accounts_teams_create(
            self,
            account,
            data,
            **kwargs
        ):
            """Create a team.  # noqa: E501

            Returns data for the new team.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.accounts_teams_create(account, data, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                data (AccountTeamCreate):

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

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

        self.accounts_teams_create = _Endpoint(
            settings={
                'response_type': (AccountTeamCreate,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/teams/',
                'operation_id': 'accounts_teams_create',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'data',
                ],
                'required': [
                    'account',
                    'data',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'data':
                        (AccountTeamCreate,),
                },
                'attribute_map': {
                    'account': 'account',
                },
                'location_map': {
                    'account': 'path',
                    'data': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__accounts_teams_create
        )

        def __accounts_teams_delete(
            self,
            account,
            team,
            **kwargs
        ):
            """Destroy a team.  # noqa: E501

            Returns an empty 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.accounts_teams_delete(account, team, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                team (str):

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

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

        self.accounts_teams_delete = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/teams/{team}/',
                'operation_id': 'accounts_teams_delete',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'team',
                ],
                'required': [
                    'account',
                    'team',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'team':
                        (str,),
                },
                'attribute_map': {
                    'account': 'account',
                    'team': 'team',
                },
                'location_map': {
                    'account': 'path',
                    'team': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_teams_delete
        )

        def __accounts_teams_list(
            self,
            account,
            **kwargs
        ):
            """List teams.  # noqa: E501

            Returns a list of teams for the 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.accounts_teams_list(account, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):

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

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

        self.accounts_teams_list = _Endpoint(
            settings={
                'response_type': (InlineResponse2002,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/teams/',
                'operation_id': 'accounts_teams_list',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'limit',
                    'offset',
                ],
                'required': [
                    'account',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'account': 'account',
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'account': 'path',
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_teams_list
        )

        def __accounts_teams_members_create(
            self,
            account,
            team,
            data,
            **kwargs
        ):
            """accounts_teams_members_create  # noqa: E501

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

            >>> thread = api.accounts_teams_members_create(account, team, data, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                team (str):
                data (UserIdentifier):

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

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

        self.accounts_teams_members_create = _Endpoint(
            settings={
                'response_type': (UserIdentifier,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/teams/{team}/members/',
                'operation_id': 'accounts_teams_members_create',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'team',
                    'data',
                ],
                'required': [
                    'account',
                    'team',
                    'data',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'team':
                        (str,),
                    'data':
                        (UserIdentifier,),
                },
                'attribute_map': {
                    'account': 'account',
                    'team': 'team',
                },
                'location_map': {
                    'account': 'path',
                    'team': 'path',
                    'data': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__accounts_teams_members_create
        )

        def __accounts_teams_members_delete(
            self,
            account,
            team,
            user,
            **kwargs
        ):
            """accounts_teams_members_delete  # noqa: E501

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

            >>> thread = api.accounts_teams_members_delete(account, team, user, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                team (str):
                user (str):

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

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

        self.accounts_teams_members_delete = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/teams/{team}/members/{user}/',
                'operation_id': 'accounts_teams_members_delete',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'team',
                    'user',
                ],
                'required': [
                    'account',
                    'team',
                    'user',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'team':
                        (str,),
                    'user':
                        (str,),
                },
                'attribute_map': {
                    'account': 'account',
                    'team': 'team',
                    'user': 'user',
                },
                'location_map': {
                    'account': 'path',
                    'team': 'path',
                    'user': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_teams_members_delete
        )

        def __accounts_teams_partial_update(
            self,
            account,
            team,
            data,
            **kwargs
        ):
            """Update a team.  # noqa: E501

            Returns data for the team.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.accounts_teams_partial_update(account, team, data, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                team (str):
                data (AccountTeamUpdate):

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

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

        self.accounts_teams_partial_update = _Endpoint(
            settings={
                'response_type': (AccountTeamUpdate,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/teams/{team}/',
                'operation_id': 'accounts_teams_partial_update',
                'http_method': 'PATCH',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'team',
                    'data',
                ],
                'required': [
                    'account',
                    'team',
                    'data',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'team':
                        (str,),
                    'data':
                        (AccountTeamUpdate,),
                },
                'attribute_map': {
                    'account': 'account',
                    'team': 'team',
                },
                'location_map': {
                    'account': 'path',
                    'team': 'path',
                    'data': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__accounts_teams_partial_update
        )

        def __accounts_teams_read(
            self,
            account,
            team,
            **kwargs
        ):
            """Retrieve a team.  # noqa: E501

            Returns data for the team.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.accounts_teams_read(account, team, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                team (str):

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

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

        self.accounts_teams_read = _Endpoint(
            settings={
                'response_type': (AccountTeam,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/teams/{team}/',
                'operation_id': 'accounts_teams_read',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'team',
                ],
                'required': [
                    'account',
                    'team',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'team':
                        (str,),
                },
                'attribute_map': {
                    'account': 'account',
                    'team': 'team',
                },
                'location_map': {
                    'account': 'path',
                    'team': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_teams_read
        )

        def __accounts_users_create(
            self,
            account,
            data,
            **kwargs
        ):
            """Create an object.  # noqa: E501

            Returns data for the new object.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.accounts_users_create(account, data, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                data (AccountUserCreate):

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

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

        self.accounts_users_create = _Endpoint(
            settings={
                'response_type': (AccountUserCreate,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/users/',
                'operation_id': 'accounts_users_create',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'data',
                ],
                'required': [
                    'account',
                    'data',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'data':
                        (AccountUserCreate,),
                },
                'attribute_map': {
                    'account': 'account',
                },
                'location_map': {
                    'account': 'path',
                    'data': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__accounts_users_create
        )

        def __accounts_users_delete(
            self,
            account,
            user,
            **kwargs
        ):
            """Destroy an object.  # noqa: E501

            Returns an empty 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.accounts_users_delete(account, user, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                user (str):

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

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

        self.accounts_users_delete = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/users/{user}/',
                'operation_id': 'accounts_users_delete',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'user',
                ],
                'required': [
                    'account',
                    'user',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'user':
                        (str,),
                },
                'attribute_map': {
                    'account': 'account',
                    'user': 'user',
                },
                'location_map': {
                    'account': 'path',
                    'user': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_users_delete
        )

        def __accounts_users_list(
            self,
            account,
            **kwargs
        ):
            """List objects.  # noqa: E501

            Returns a list of objects.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.accounts_users_list(account, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):

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

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

        self.accounts_users_list = _Endpoint(
            settings={
                'response_type': (InlineResponse2003,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/users/',
                'operation_id': 'accounts_users_list',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'limit',
                    'offset',
                ],
                'required': [
                    'account',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'account': 'account',
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'account': 'path',
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_users_list
        )

        def __accounts_users_partial_update(
            self,
            account,
            user,
            data,
            **kwargs
        ):
            """Update an object.  # noqa: E501

            Returns data for the updated object.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.accounts_users_partial_update(account, user, data, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                user (str):
                data (AccountUserPatch):

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

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

        self.accounts_users_partial_update = _Endpoint(
            settings={
                'response_type': (AccountUserPatch,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/users/{user}/',
                'operation_id': 'accounts_users_partial_update',
                'http_method': 'PATCH',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'user',
                    'data',
                ],
                'required': [
                    'account',
                    'user',
                    'data',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'user':
                        (str,),
                    'data':
                        (AccountUserPatch,),
                },
                'attribute_map': {
                    'account': 'account',
                    'user': 'user',
                },
                'location_map': {
                    'account': 'path',
                    'user': 'path',
                    'data': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__accounts_users_partial_update
        )

        def __accounts_users_read(
            self,
            account,
            user,
            **kwargs
        ):
            """Retrieve an object.  # noqa: E501

            Returns data for the object.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.accounts_users_read(account, user, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                user (str):

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

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

        self.accounts_users_read = _Endpoint(
            settings={
                'response_type': (AccountUser,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/users/{user}/',
                'operation_id': 'accounts_users_read',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'user',
                ],
                'required': [
                    'account',
                    'user',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'user':
                        (str,),
                },
                'attribute_map': {
                    'account': 'account',
                    'user': 'user',
                },
                'location_map': {
                    'account': 'path',
                    'user': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_users_read
        )

        def __accounts_workers_heartbeats_list(
            self,
            account,
            worker,
            **kwargs
        ):
            """List objects.  # noqa: E501

            Returns a list of objects.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.accounts_workers_heartbeats_list(account, worker, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                worker (str):

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

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

        self.accounts_workers_heartbeats_list = _Endpoint(
            settings={
                'response_type': (InlineResponse2005,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/workers/{worker}/heartbeats/',
                'operation_id': 'accounts_workers_heartbeats_list',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'worker',
                    'limit',
                    'offset',
                ],
                'required': [
                    'account',
                    'worker',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'worker':
                        (str,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'account': 'account',
                    'worker': 'worker',
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'account': 'path',
                    'worker': 'path',
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_workers_heartbeats_list
        )

        def __accounts_workers_list(
            self,
            account,
            **kwargs
        ):
            """List objects.  # noqa: E501

            Returns a list of objects.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.accounts_workers_list(account, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):

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

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

        self.accounts_workers_list = _Endpoint(
            settings={
                'response_type': (InlineResponse2004,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/workers/',
                'operation_id': 'accounts_workers_list',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'limit',
                    'offset',
                ],
                'required': [
                    'account',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'account': 'account',
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'account': 'path',
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_workers_list
        )

        def __accounts_workers_read(
            self,
            account,
            worker,
            **kwargs
        ):
            """Retrieve an object.  # noqa: E501

            Returns data for the object.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.accounts_workers_read(account, worker, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                worker (str):

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

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

        self.accounts_workers_read = _Endpoint(
            settings={
                'response_type': (Worker,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/workers/{worker}/',
                'operation_id': 'accounts_workers_read',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'worker',
                ],
                'required': [
                    'account',
                    'worker',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'worker':
                        (str,),
                },
                'attribute_map': {
                    'account': 'account',
                    'worker': 'worker',
                },
                'location_map': {
                    'account': 'path',
                    'worker': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_workers_read
        )

        def __accounts_zones_create(
            self,
            account,
            data,
            **kwargs
        ):
            """Create an object.  # noqa: E501

            Returns data for the new object.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.accounts_zones_create(account, data, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                data (ZoneCreate):

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

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

        self.accounts_zones_create = _Endpoint(
            settings={
                'response_type': (ZoneCreate,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/zones/',
                'operation_id': 'accounts_zones_create',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'data',
                ],
                'required': [
                    'account',
                    'data',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'data':
                        (ZoneCreate,),
                },
                'attribute_map': {
                    'account': 'account',
                },
                'location_map': {
                    'account': 'path',
                    'data': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client,
            callable=__accounts_zones_create
        )

        def __accounts_zones_delete(
            self,
            account,
            zone,
            **kwargs
        ):
            """Destroy an object.  # noqa: E501

            Returns an empty 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.accounts_zones_delete(account, zone, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                zone (str):

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

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

        self.accounts_zones_delete = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/zones/{zone}/',
                'operation_id': 'accounts_zones_delete',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'zone',
                ],
                'required': [
                    'account',
                    'zone',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'zone':
                        (str,),
                },
                'attribute_map': {
                    'account': 'account',
                    'zone': 'zone',
                },
                'location_map': {
                    'account': 'path',
                    'zone': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_zones_delete
        )

        def __accounts_zones_list(
            self,
            account,
            **kwargs
        ):
            """List objects.  # noqa: E501

            Returns a list of objects.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.accounts_zones_list(account, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):

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

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

        self.accounts_zones_list = _Endpoint(
            settings={
                'response_type': (InlineResponse2006,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/zones/',
                'operation_id': 'accounts_zones_list',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'limit',
                    'offset',
                ],
                'required': [
                    'account',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'limit':
                        (int,),
                    'offset':
                        (int,),
                },
                'attribute_map': {
                    'account': 'account',
                    'limit': 'limit',
                    'offset': 'offset',
                },
                'location_map': {
                    'account': 'path',
                    'limit': 'query',
                    'offset': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_zones_list
        )

        def __accounts_zones_read(
            self,
            account,
            zone,
            **kwargs
        ):
            """Retrieve an object.  # noqa: E501

            Returns data for the object.  # noqa: E501
            This method makes a synchronous HTTP request by default. To make an
            asynchronous HTTP request, please pass async_req=True

            >>> thread = api.accounts_zones_read(account, zone, async_req=True)
            >>> result = thread.get()

            Args:
                account (str):
                zone (str):

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

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

        self.accounts_zones_read = _Endpoint(
            settings={
                'response_type': (Zone,),
                'auth': [
                    'Token'
                ],
                'endpoint_path': '/accounts/{account}/zones/{zone}/',
                'operation_id': 'accounts_zones_read',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'account',
                    'zone',
                ],
                'required': [
                    'account',
                    'zone',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'account':
                        (str,),
                    'zone':
                        (str,),
                },
                'attribute_map': {
                    'account': 'account',
                    'zone': 'zone',
                },
                'location_map': {
                    'account': 'path',
                    'zone': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client,
            callable=__accounts_zones_read
        )
