Module mailslurp_client.api.agent_controller_api

MailSlurp API

MailSlurp is an API for sending and receiving emails and SMS from dynamically allocated email addresses and phone numbers. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more. ## Resources - Homepage - Get an API KEY - Generated SDK Clients - Examples repository # noqa: E501

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

Classes

class AgentControllerApi (api_client=None)

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Expand source code

class AgentControllerApi(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 agent_acquire_conversation_claim(self, conversation_id, acquire_agent_conversation_claim_options, **kwargs):  # noqa: E501
        """Acquire a renewable conversation claim  # noqa: E501

        Atomically leases a conversation to one worker. A conflict means another unexpired worker owns it. Use expectedVersion to reject work selected from stale context.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_acquire_conversation_claim(conversation_id, acquire_agent_conversation_claim_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param AcquireAgentConversationClaimOptions acquire_agent_conversation_claim_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentConversationClaimDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_acquire_conversation_claim_with_http_info(conversation_id, acquire_agent_conversation_claim_options, **kwargs)  # noqa: E501

    def agent_acquire_conversation_claim_with_http_info(self, conversation_id, acquire_agent_conversation_claim_options, **kwargs):  # noqa: E501
        """Acquire a renewable conversation claim  # noqa: E501

        Atomically leases a conversation to one worker. A conflict means another unexpired worker owns it. Use expectedVersion to reject work selected from stale context.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_acquire_conversation_claim_with_http_info(conversation_id, acquire_agent_conversation_claim_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param AcquireAgentConversationClaimOptions acquire_agent_conversation_claim_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentConversationClaimDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'conversation_id',
            'acquire_agent_conversation_claim_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_acquire_conversation_claim" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'conversation_id' is set
        if self.api_client.client_side_validation and ('conversation_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['conversation_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `conversation_id` when calling `agent_acquire_conversation_claim`")  # noqa: E501
        # verify the required parameter 'acquire_agent_conversation_claim_options' is set
        if self.api_client.client_side_validation and ('acquire_agent_conversation_claim_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['acquire_agent_conversation_claim_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `acquire_agent_conversation_claim_options` when calling `agent_acquire_conversation_claim`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'conversation_id' in local_var_params:
            path_params['conversationId'] = local_var_params['conversation_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'acquire_agent_conversation_claim_options' in local_var_params:
            body_params = local_var_params['acquire_agent_conversation_claim_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/conversations/{conversationId}/claims', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentConversationClaimDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_add_conversation_note(self, conversation_id, create_agent_conversation_note_options, **kwargs):  # noqa: E501
        """Add an internal conversation note  # noqa: E501

        Adds agent/operator collaboration context without sending any email to the customer.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_add_conversation_note(conversation_id, create_agent_conversation_note_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param CreateAgentConversationNoteOptions create_agent_conversation_note_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentConversationNoteDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_add_conversation_note_with_http_info(conversation_id, create_agent_conversation_note_options, **kwargs)  # noqa: E501

    def agent_add_conversation_note_with_http_info(self, conversation_id, create_agent_conversation_note_options, **kwargs):  # noqa: E501
        """Add an internal conversation note  # noqa: E501

        Adds agent/operator collaboration context without sending any email to the customer.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_add_conversation_note_with_http_info(conversation_id, create_agent_conversation_note_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param CreateAgentConversationNoteOptions create_agent_conversation_note_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentConversationNoteDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'conversation_id',
            'create_agent_conversation_note_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_add_conversation_note" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'conversation_id' is set
        if self.api_client.client_side_validation and ('conversation_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['conversation_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `conversation_id` when calling `agent_add_conversation_note`")  # noqa: E501
        # verify the required parameter 'create_agent_conversation_note_options' is set
        if self.api_client.client_side_validation and ('create_agent_conversation_note_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_agent_conversation_note_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_agent_conversation_note_options` when calling `agent_add_conversation_note`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'conversation_id' in local_var_params:
            path_params['conversationId'] = local_var_params['conversation_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_agent_conversation_note_options' in local_var_params:
            body_params = local_var_params['create_agent_conversation_note_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/conversations/{conversationId}/notes', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentConversationNoteDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_add_sms_note(self, conversation_id, create_agent_sms_conversation_note_options, **kwargs):  # noqa: E501
        """Add an internal SMS conversation note  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_add_sms_note(conversation_id, create_agent_sms_conversation_note_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param CreateAgentSmsConversationNoteOptions create_agent_sms_conversation_note_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentConversationNoteDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_add_sms_note_with_http_info(conversation_id, create_agent_sms_conversation_note_options, **kwargs)  # noqa: E501

    def agent_add_sms_note_with_http_info(self, conversation_id, create_agent_sms_conversation_note_options, **kwargs):  # noqa: E501
        """Add an internal SMS conversation note  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_add_sms_note_with_http_info(conversation_id, create_agent_sms_conversation_note_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param CreateAgentSmsConversationNoteOptions create_agent_sms_conversation_note_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentConversationNoteDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'conversation_id',
            'create_agent_sms_conversation_note_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_add_sms_note" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'conversation_id' is set
        if self.api_client.client_side_validation and ('conversation_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['conversation_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `conversation_id` when calling `agent_add_sms_note`")  # noqa: E501
        # verify the required parameter 'create_agent_sms_conversation_note_options' is set
        if self.api_client.client_side_validation and ('create_agent_sms_conversation_note_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_agent_sms_conversation_note_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_agent_sms_conversation_note_options` when calling `agent_add_sms_note`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'conversation_id' in local_var_params:
            path_params['conversationId'] = local_var_params['conversation_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_agent_sms_conversation_note_options' in local_var_params:
            body_params = local_var_params['create_agent_sms_conversation_note_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/sms-conversations/{conversationId}/notes', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentConversationNoteDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_check_inbox_send_policy(self, inbox_id, agent_inbox_send_policy_check_options, **kwargs):  # noqa: E501
        """Check whether sending rules allow recipients  # noqa: E501

        Evaluates effective inbox and account sending rules before an agent creates a send action. A blocked result includes the operator recovery route.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_check_inbox_send_policy(inbox_id, agent_inbox_send_policy_check_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param AgentInboxSendPolicyCheckOptions agent_inbox_send_policy_check_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentInboxSendPolicyDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_check_inbox_send_policy_with_http_info(inbox_id, agent_inbox_send_policy_check_options, **kwargs)  # noqa: E501

    def agent_check_inbox_send_policy_with_http_info(self, inbox_id, agent_inbox_send_policy_check_options, **kwargs):  # noqa: E501
        """Check whether sending rules allow recipients  # noqa: E501

        Evaluates effective inbox and account sending rules before an agent creates a send action. A blocked result includes the operator recovery route.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_check_inbox_send_policy_with_http_info(inbox_id, agent_inbox_send_policy_check_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param AgentInboxSendPolicyCheckOptions agent_inbox_send_policy_check_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentInboxSendPolicyDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'agent_inbox_send_policy_check_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_check_inbox_send_policy" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `agent_check_inbox_send_policy`")  # noqa: E501
        # verify the required parameter 'agent_inbox_send_policy_check_options' is set
        if self.api_client.client_side_validation and ('agent_inbox_send_policy_check_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['agent_inbox_send_policy_check_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `agent_inbox_send_policy_check_options` when calling `agent_check_inbox_send_policy`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'agent_inbox_send_policy_check_options' in local_var_params:
            body_params = local_var_params['agent_inbox_send_policy_check_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/inboxes/{inboxId}/send-policy/check', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentInboxSendPolicyDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_claim_sms_conversation(self, conversation_id, acquire_agent_conversation_claim_options, **kwargs):  # noqa: E501
        """Acquire an SMS conversation claim  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_claim_sms_conversation(conversation_id, acquire_agent_conversation_claim_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param AcquireAgentConversationClaimOptions acquire_agent_conversation_claim_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentConversationClaimDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_claim_sms_conversation_with_http_info(conversation_id, acquire_agent_conversation_claim_options, **kwargs)  # noqa: E501

    def agent_claim_sms_conversation_with_http_info(self, conversation_id, acquire_agent_conversation_claim_options, **kwargs):  # noqa: E501
        """Acquire an SMS conversation claim  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_claim_sms_conversation_with_http_info(conversation_id, acquire_agent_conversation_claim_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param AcquireAgentConversationClaimOptions acquire_agent_conversation_claim_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentConversationClaimDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'conversation_id',
            'acquire_agent_conversation_claim_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_claim_sms_conversation" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'conversation_id' is set
        if self.api_client.client_side_validation and ('conversation_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['conversation_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `conversation_id` when calling `agent_claim_sms_conversation`")  # noqa: E501
        # verify the required parameter 'acquire_agent_conversation_claim_options' is set
        if self.api_client.client_side_validation and ('acquire_agent_conversation_claim_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['acquire_agent_conversation_claim_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `acquire_agent_conversation_claim_options` when calling `agent_claim_sms_conversation`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'conversation_id' in local_var_params:
            path_params['conversationId'] = local_var_params['conversation_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'acquire_agent_conversation_claim_options' in local_var_params:
            body_params = local_var_params['acquire_agent_conversation_claim_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/sms-conversations/{conversationId}/claims', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentConversationClaimDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_complete_work_item(self, conversation_id, complete_agent_work_item_options, **kwargs):  # noqa: E501
        """Complete a work item with an idempotent reply  # noqa: E501

        Revalidates conversation freshness, sends one threaded reply with an idempotency key, and releases the supplied claim only after the send succeeds.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_complete_work_item(conversation_id, complete_agent_work_item_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param CompleteAgentWorkItemOptions complete_agent_work_item_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentCompletedWorkItemDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_complete_work_item_with_http_info(conversation_id, complete_agent_work_item_options, **kwargs)  # noqa: E501

    def agent_complete_work_item_with_http_info(self, conversation_id, complete_agent_work_item_options, **kwargs):  # noqa: E501
        """Complete a work item with an idempotent reply  # noqa: E501

        Revalidates conversation freshness, sends one threaded reply with an idempotency key, and releases the supplied claim only after the send succeeds.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_complete_work_item_with_http_info(conversation_id, complete_agent_work_item_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param CompleteAgentWorkItemOptions complete_agent_work_item_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentCompletedWorkItemDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'conversation_id',
            'complete_agent_work_item_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_complete_work_item" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'conversation_id' is set
        if self.api_client.client_side_validation and ('conversation_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['conversation_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `conversation_id` when calling `agent_complete_work_item`")  # noqa: E501
        # verify the required parameter 'complete_agent_work_item_options' is set
        if self.api_client.client_side_validation and ('complete_agent_work_item_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['complete_agent_work_item_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `complete_agent_work_item_options` when calling `agent_complete_work_item`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'conversation_id' in local_var_params:
            path_params['conversationId'] = local_var_params['conversation_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'complete_agent_work_item_options' in local_var_params:
            body_params = local_var_params['complete_agent_work_item_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/work-items/{conversationId}/complete', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentCompletedWorkItemDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_create_email_draft(self, inbox_id, send_email_options, **kwargs):  # noqa: E501
        """Create a scoped email draft for an agent  # noqa: E501

        Creates a saved draft in the path inbox using the same SendEmailOptions shape as sending, without sending the email.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_create_email_draft(inbox_id, send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox to save the draft against (required)
        :param SendEmailOptions send_email_options: (required)
        :param str source_email_id: Optional source email this draft responds to. When supplied, MailSlurp links the draft and later draft actions to that conversation.
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: EmailDraftDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_create_email_draft_with_http_info(inbox_id, send_email_options, **kwargs)  # noqa: E501

    def agent_create_email_draft_with_http_info(self, inbox_id, send_email_options, **kwargs):  # noqa: E501
        """Create a scoped email draft for an agent  # noqa: E501

        Creates a saved draft in the path inbox using the same SendEmailOptions shape as sending, without sending the email.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_create_email_draft_with_http_info(inbox_id, send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox to save the draft against (required)
        :param SendEmailOptions send_email_options: (required)
        :param str source_email_id: Optional source email this draft responds to. When supplied, MailSlurp links the draft and later draft actions to that conversation.
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(EmailDraftDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'send_email_options',
            'source_email_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_create_email_draft" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `agent_create_email_draft`")  # noqa: E501
        # verify the required parameter 'send_email_options' is set
        if self.api_client.client_side_validation and ('send_email_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['send_email_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `send_email_options` when calling `agent_create_email_draft`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []
        if 'source_email_id' in local_var_params and local_var_params['source_email_id'] is not None:  # noqa: E501
            query_params.append(('sourceEmailId', local_var_params['source_email_id']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'send_email_options' in local_var_params:
            body_params = local_var_params['send_email_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/inboxes/{inboxId}/drafts', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmailDraftDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_create_inbox(self, create_inbox_dto, **kwargs):  # noqa: E501
        """Create an inbox with an account-wide inbox-manager connection  # noqa: E501

        Creates an inbox without changing this agent connection's scopes. Account-wide scope is required so the new inbox is already covered.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_create_inbox(create_inbox_dto, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateInboxDto create_inbox_dto: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: InboxDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_create_inbox_with_http_info(create_inbox_dto, **kwargs)  # noqa: E501

    def agent_create_inbox_with_http_info(self, create_inbox_dto, **kwargs):  # noqa: E501
        """Create an inbox with an account-wide inbox-manager connection  # noqa: E501

        Creates an inbox without changing this agent connection's scopes. Account-wide scope is required so the new inbox is already covered.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_create_inbox_with_http_info(create_inbox_dto, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateInboxDto create_inbox_dto: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(InboxDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_inbox_dto'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_create_inbox" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'create_inbox_dto' is set
        if self.api_client.client_side_validation and ('create_inbox_dto' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_inbox_dto'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_inbox_dto` when calling `agent_create_inbox`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_inbox_dto' in local_var_params:
            body_params = local_var_params['create_inbox_dto']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/inboxes', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_create_reply_draft(self, email_id, reply_to_email_options, **kwargs):  # noqa: E501
        """Create a correctly threaded reply draft  # noqa: E501

        Builds the same recipients and RFC In-Reply-To/References headers as immediate reply, saves them as a draft, and preserves the required threading headers across later agent draft updates.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_create_reply_draft(email_id, reply_to_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param ReplyToEmailOptions reply_to_email_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: EmailDraftDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_create_reply_draft_with_http_info(email_id, reply_to_email_options, **kwargs)  # noqa: E501

    def agent_create_reply_draft_with_http_info(self, email_id, reply_to_email_options, **kwargs):  # noqa: E501
        """Create a correctly threaded reply draft  # noqa: E501

        Builds the same recipients and RFC In-Reply-To/References headers as immediate reply, saves them as a draft, and preserves the required threading headers across later agent draft updates.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_create_reply_draft_with_http_info(email_id, reply_to_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param ReplyToEmailOptions reply_to_email_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(EmailDraftDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'reply_to_email_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_create_reply_draft" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `agent_create_reply_draft`")  # noqa: E501
        # verify the required parameter 'reply_to_email_options' is set
        if self.api_client.client_side_validation and ('reply_to_email_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['reply_to_email_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `reply_to_email_options` when calling `agent_create_reply_draft`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'reply_to_email_options' in local_var_params:
            body_params = local_var_params['reply_to_email_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/emails/{emailId}/reply-draft', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmailDraftDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_create_totp_device_for_base32_secret_key(self, create_totp_device_base32_secret_key_options, **kwargs):  # noqa: E501
        """Create an agent-managed TOTP device from a base32 secret key  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_create_totp_device_for_base32_secret_key(create_totp_device_base32_secret_key_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateTotpDeviceBase32SecretKeyOptions create_totp_device_base32_secret_key_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: TotpDeviceDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_create_totp_device_for_base32_secret_key_with_http_info(create_totp_device_base32_secret_key_options, **kwargs)  # noqa: E501

    def agent_create_totp_device_for_base32_secret_key_with_http_info(self, create_totp_device_base32_secret_key_options, **kwargs):  # noqa: E501
        """Create an agent-managed TOTP device from a base32 secret key  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_create_totp_device_for_base32_secret_key_with_http_info(create_totp_device_base32_secret_key_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateTotpDeviceBase32SecretKeyOptions create_totp_device_base32_secret_key_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(TotpDeviceDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_totp_device_base32_secret_key_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_create_totp_device_for_base32_secret_key" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'create_totp_device_base32_secret_key_options' is set
        if self.api_client.client_side_validation and ('create_totp_device_base32_secret_key_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_totp_device_base32_secret_key_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_totp_device_base32_secret_key_options` when calling `agent_create_totp_device_for_base32_secret_key`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_totp_device_base32_secret_key_options' in local_var_params:
            body_params = local_var_params['create_totp_device_base32_secret_key_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/totp/devices/base32-secret-key', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TotpDeviceDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_create_totp_device_for_custom(self, create_totp_device_custom_options, **kwargs):  # noqa: E501
        """Create an agent-managed TOTP device from custom options  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_create_totp_device_for_custom(create_totp_device_custom_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateTotpDeviceCustomOptions create_totp_device_custom_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: TotpDeviceDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_create_totp_device_for_custom_with_http_info(create_totp_device_custom_options, **kwargs)  # noqa: E501

    def agent_create_totp_device_for_custom_with_http_info(self, create_totp_device_custom_options, **kwargs):  # noqa: E501
        """Create an agent-managed TOTP device from custom options  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_create_totp_device_for_custom_with_http_info(create_totp_device_custom_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateTotpDeviceCustomOptions create_totp_device_custom_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(TotpDeviceDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_totp_device_custom_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_create_totp_device_for_custom" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'create_totp_device_custom_options' is set
        if self.api_client.client_side_validation and ('create_totp_device_custom_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_totp_device_custom_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_totp_device_custom_options` when calling `agent_create_totp_device_for_custom`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_totp_device_custom_options' in local_var_params:
            body_params = local_var_params['create_totp_device_custom_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/totp/devices/custom', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TotpDeviceDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_create_totp_device_for_otp_auth_url(self, create_totp_device_otp_auth_url_options, **kwargs):  # noqa: E501
        """Create an agent-managed TOTP device from an OTP Auth URL  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_create_totp_device_for_otp_auth_url(create_totp_device_otp_auth_url_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateTotpDeviceOtpAuthUrlOptions create_totp_device_otp_auth_url_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: TotpDeviceDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_create_totp_device_for_otp_auth_url_with_http_info(create_totp_device_otp_auth_url_options, **kwargs)  # noqa: E501

    def agent_create_totp_device_for_otp_auth_url_with_http_info(self, create_totp_device_otp_auth_url_options, **kwargs):  # noqa: E501
        """Create an agent-managed TOTP device from an OTP Auth URL  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_create_totp_device_for_otp_auth_url_with_http_info(create_totp_device_otp_auth_url_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateTotpDeviceOtpAuthUrlOptions create_totp_device_otp_auth_url_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(TotpDeviceDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_totp_device_otp_auth_url_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_create_totp_device_for_otp_auth_url" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'create_totp_device_otp_auth_url_options' is set
        if self.api_client.client_side_validation and ('create_totp_device_otp_auth_url_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_totp_device_otp_auth_url_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_totp_device_otp_auth_url_options` when calling `agent_create_totp_device_for_otp_auth_url`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_totp_device_otp_auth_url_options' in local_var_params:
            body_params = local_var_params['create_totp_device_otp_auth_url_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/totp/devices/otp-auth-url', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TotpDeviceDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_defer_work_item(self, conversation_id, defer_agent_work_item_options, **kwargs):  # noqa: E501
        """Defer a work item to human review  # noqa: E501

        Creates or returns the active review handoff and releases the supplied claim after the handoff is durable. Deferral is a normal workflow result rather than an operational failure.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_defer_work_item(conversation_id, defer_agent_work_item_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param DeferAgentWorkItemOptions defer_agent_work_item_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentDeferredWorkItemDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_defer_work_item_with_http_info(conversation_id, defer_agent_work_item_options, **kwargs)  # noqa: E501

    def agent_defer_work_item_with_http_info(self, conversation_id, defer_agent_work_item_options, **kwargs):  # noqa: E501
        """Defer a work item to human review  # noqa: E501

        Creates or returns the active review handoff and releases the supplied claim after the handoff is durable. Deferral is a normal workflow result rather than an operational failure.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_defer_work_item_with_http_info(conversation_id, defer_agent_work_item_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param DeferAgentWorkItemOptions defer_agent_work_item_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentDeferredWorkItemDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'conversation_id',
            'defer_agent_work_item_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_defer_work_item" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'conversation_id' is set
        if self.api_client.client_side_validation and ('conversation_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['conversation_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `conversation_id` when calling `agent_defer_work_item`")  # noqa: E501
        # verify the required parameter 'defer_agent_work_item_options' is set
        if self.api_client.client_side_validation and ('defer_agent_work_item_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['defer_agent_work_item_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `defer_agent_work_item_options` when calling `agent_defer_work_item`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'conversation_id' in local_var_params:
            path_params['conversationId'] = local_var_params['conversation_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'defer_agent_work_item_options' in local_var_params:
            body_params = local_var_params['defer_agent_work_item_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/work-items/{conversationId}/defer', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentDeferredWorkItemDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_delete_email_draft(self, inbox_id, draft_id, **kwargs):  # noqa: E501
        """Delete a scoped email draft for an agent  # noqa: E501

        Deletes a saved draft without sending it.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_delete_email_draft(inbox_id, draft_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox the draft belongs to (required)
        :param str draft_id: ID of draft (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_delete_email_draft_with_http_info(inbox_id, draft_id, **kwargs)  # noqa: E501

    def agent_delete_email_draft_with_http_info(self, inbox_id, draft_id, **kwargs):  # noqa: E501
        """Delete a scoped email draft for an agent  # noqa: E501

        Deletes a saved draft without sending it.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_delete_email_draft_with_http_info(inbox_id, draft_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox the draft belongs to (required)
        :param str draft_id: ID of draft (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'draft_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_delete_email_draft" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `agent_delete_email_draft`")  # noqa: E501
        # verify the required parameter 'draft_id' is set
        if self.api_client.client_side_validation and ('draft_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['draft_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `draft_id` when calling `agent_delete_email_draft`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501
        if 'draft_id' in local_var_params:
            path_params['draftId'] = local_var_params['draft_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/inboxes/{inboxId}/drafts/{draftId}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_delete_totp_device(self, id, **kwargs):  # noqa: E501
        """Delete an agent-managed TOTP device  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_delete_totp_device(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_delete_totp_device_with_http_info(id, **kwargs)  # noqa: E501

    def agent_delete_totp_device_with_http_info(self, id, **kwargs):  # noqa: E501
        """Delete an agent-managed TOTP device  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_delete_totp_device_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_delete_totp_device" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `agent_delete_totp_device`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/totp/devices/{id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_extract_email_attachment_text(self, email_id, attachment_id, **kwargs):  # noqa: E501
        """Extract text from a scoped email attachment for an agent  # noqa: E501

        Extracts bounded text only after verifying both the email scope and that the attachment belongs to that email. List attachments first instead of guessing IDs.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_extract_email_attachment_text(email_id, attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param str attachment_id: (required)
        :param ExtractAttachmentTextOptions extract_attachment_text_options:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: ExtractAttachmentTextResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_extract_email_attachment_text_with_http_info(email_id, attachment_id, **kwargs)  # noqa: E501

    def agent_extract_email_attachment_text_with_http_info(self, email_id, attachment_id, **kwargs):  # noqa: E501
        """Extract text from a scoped email attachment for an agent  # noqa: E501

        Extracts bounded text only after verifying both the email scope and that the attachment belongs to that email. List attachments first instead of guessing IDs.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_extract_email_attachment_text_with_http_info(email_id, attachment_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param str attachment_id: (required)
        :param ExtractAttachmentTextOptions extract_attachment_text_options:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(ExtractAttachmentTextResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'attachment_id',
            'extract_attachment_text_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_extract_email_attachment_text" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `agent_extract_email_attachment_text`")  # noqa: E501
        # verify the required parameter 'attachment_id' is set
        if self.api_client.client_side_validation and ('attachment_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['attachment_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `attachment_id` when calling `agent_extract_email_attachment_text`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501
        if 'attachment_id' in local_var_params:
            path_params['attachmentId'] = local_var_params['attachment_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'extract_attachment_text_options' in local_var_params:
            body_params = local_var_params['extract_attachment_text_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/emails/{emailId}/attachments/{attachmentId}/text', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ExtractAttachmentTextResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_generate_totp_device_code(self, id, **kwargs):  # noqa: E501
        """Generate a code for an agent-managed TOTP device  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_generate_totp_device_code(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param datetime at:
        :param int min_seconds_until_expire: Minimum remaining code lifetime. The request may wait for the next period when needed.
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: TotpDeviceCodeDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_generate_totp_device_code_with_http_info(id, **kwargs)  # noqa: E501

    def agent_generate_totp_device_code_with_http_info(self, id, **kwargs):  # noqa: E501
        """Generate a code for an agent-managed TOTP device  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_generate_totp_device_code_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param datetime at:
        :param int min_seconds_until_expire: Minimum remaining code lifetime. The request may wait for the next period when needed.
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(TotpDeviceCodeDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'id',
            'at',
            'min_seconds_until_expire'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_generate_totp_device_code" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `agent_generate_totp_device_code`")  # noqa: E501

        if self.api_client.client_side_validation and 'min_seconds_until_expire' in local_var_params and local_var_params['min_seconds_until_expire'] > 30:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `min_seconds_until_expire` when calling `agent_generate_totp_device_code`, must be a value less than or equal to `30`")  # noqa: E501
        if self.api_client.client_side_validation and 'min_seconds_until_expire' in local_var_params and local_var_params['min_seconds_until_expire'] < 1:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `min_seconds_until_expire` when calling `agent_generate_totp_device_code`, must be a value greater than or equal to `1`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []
        if 'at' in local_var_params and local_var_params['at'] is not None:  # noqa: E501
            query_params.append(('at', local_var_params['at']))  # noqa: E501
        if 'min_seconds_until_expire' in local_var_params and local_var_params['min_seconds_until_expire'] is not None:  # noqa: E501
            query_params.append(('minSecondsUntilExpire', local_var_params['min_seconds_until_expire']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/totp/devices/{id}/code', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TotpDeviceCodeDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_capabilities(self, **kwargs):  # noqa: E501
        """Discover this agent connection's capabilities  # noqa: E501

        Returns the connection identity, role, effective permission names, declared resource scope, feature availability, and server-enforced limits. Call this once during worker startup instead of hard-coding role behavior.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_capabilities(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentCapabilitiesDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_capabilities_with_http_info(**kwargs)  # noqa: E501

    def agent_get_capabilities_with_http_info(self, **kwargs):  # noqa: E501
        """Discover this agent connection's capabilities  # noqa: E501

        Returns the connection identity, role, effective permission names, declared resource scope, feature availability, and server-enforced limits. Call this once during worker startup instead of hard-coding role behavior.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_capabilities_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentCapabilitiesDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_capabilities" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/capabilities', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentCapabilitiesDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_conversation_v2(self, conversation_id, **kwargs):  # noqa: E501
        """Get one scoped conversation  # noqa: E501

        Returns the projected conversation plus this connection's bounded activity timeline, internal notes, and active human-review handoff.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_conversation_v2(conversation_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentConversationDetailV2Dto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_conversation_v2_with_http_info(conversation_id, **kwargs)  # noqa: E501

    def agent_get_conversation_v2_with_http_info(self, conversation_id, **kwargs):  # noqa: E501
        """Get one scoped conversation  # noqa: E501

        Returns the projected conversation plus this connection's bounded activity timeline, internal notes, and active human-review handoff.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_conversation_v2_with_http_info(conversation_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentConversationDetailV2Dto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'conversation_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_conversation_v2" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'conversation_id' is set
        if self.api_client.client_side_validation and ('conversation_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['conversation_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `conversation_id` when calling `agent_get_conversation_v2`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'conversation_id' in local_var_params:
            path_params['conversationId'] = local_var_params['conversation_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/conversations/{conversationId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentConversationDetailV2Dto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_email(self, email_id, **kwargs):  # noqa: E501
        """Get scoped hydrated email for an agent  # noqa: E501

        Returns parsed email content after resolving the message inbox and checking agent scope.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_email(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to inspect (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Email
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_email_with_http_info(email_id, **kwargs)  # noqa: E501

    def agent_get_email_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Get scoped hydrated email for an agent  # noqa: E501

        Returns parsed email content after resolving the message inbox and checking agent scope.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_email_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to inspect (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(Email, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_email" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `agent_get_email`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/emails/{emailId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Email',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_email_draft(self, inbox_id, draft_id, **kwargs):  # noqa: E501
        """Get a scoped email draft for an agent  # noqa: E501

        Returns a saved draft including the full SendEmailOptions payload.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_email_draft(inbox_id, draft_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox the draft belongs to (required)
        :param str draft_id: ID of draft (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: EmailDraftDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_email_draft_with_http_info(inbox_id, draft_id, **kwargs)  # noqa: E501

    def agent_get_email_draft_with_http_info(self, inbox_id, draft_id, **kwargs):  # noqa: E501
        """Get a scoped email draft for an agent  # noqa: E501

        Returns a saved draft including the full SendEmailOptions payload.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_email_draft_with_http_info(inbox_id, draft_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox the draft belongs to (required)
        :param str draft_id: ID of draft (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(EmailDraftDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'draft_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_email_draft" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `agent_get_email_draft`")  # noqa: E501
        # verify the required parameter 'draft_id' is set
        if self.api_client.client_side_validation and ('draft_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['draft_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `draft_id` when calling `agent_get_email_draft`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501
        if 'draft_id' in local_var_params:
            path_params['draftId'] = local_var_params['draft_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/inboxes/{inboxId}/drafts/{draftId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmailDraftDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_email_summary(self, email_id, **kwargs):  # noqa: E501
        """Get scoped email summary for an agent  # noqa: E501

        Returns lightweight metadata and headers for an email after resolving its inbox and checking the agent key scope.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_email_summary(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to inspect (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: EmailPreview
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_email_summary_with_http_info(email_id, **kwargs)  # noqa: E501

    def agent_get_email_summary_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Get scoped email summary for an agent  # noqa: E501

        Returns lightweight metadata and headers for an email after resolving its inbox and checking the agent key scope.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_email_summary_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to inspect (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(EmailPreview, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_email_summary" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `agent_get_email_summary`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/emails/{emailId}/summary', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmailPreview',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_email_thread(self, email_id, **kwargs):  # noqa: E501
        """Get a scoped email thread for an agent  # noqa: E501

        Returns thread metadata and ordered messages using an email ID as the authorization anchor. Arbitrary thread-ID probing is not allowed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_email_thread(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param str sort:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: ScopedEmailThread
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_email_thread_with_http_info(email_id, **kwargs)  # noqa: E501

    def agent_get_email_thread_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Get a scoped email thread for an agent  # noqa: E501

        Returns thread metadata and ordered messages using an email ID as the authorization anchor. Arbitrary thread-ID probing is not allowed.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_email_thread_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param str sort:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(ScopedEmailThread, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'sort'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_email_thread" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `agent_get_email_thread`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []
        if 'sort' in local_var_params and local_var_params['sort'] is not None:  # noqa: E501
            query_params.append(('sort', local_var_params['sort']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/emails/{emailId}/thread', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='ScopedEmailThread',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_latest_inbox_email(self, inbox_id, **kwargs):  # noqa: E501
        """Get latest scoped inbox email for an agent  # noqa: E501

        Waits for and returns the latest email in one scoped inbox. This is the agent-shaped equivalent of latest-message polling.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_latest_inbox_email(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox the agent may read (required)
        :param int timeout_millis: Timeout milliseconds to wait for latest email
        :param bool unread_only: Only return unread emails
        :param datetime since: Only return email received at or after this time
        :param datetime before: Only return email received before this time
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Email
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_latest_inbox_email_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def agent_get_latest_inbox_email_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """Get latest scoped inbox email for an agent  # noqa: E501

        Waits for and returns the latest email in one scoped inbox. This is the agent-shaped equivalent of latest-message polling.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_latest_inbox_email_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox the agent may read (required)
        :param int timeout_millis: Timeout milliseconds to wait for latest email
        :param bool unread_only: Only return unread emails
        :param datetime since: Only return email received at or after this time
        :param datetime before: Only return email received before this time
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(Email, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'timeout_millis',
            'unread_only',
            'since',
            'before'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_latest_inbox_email" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `agent_get_latest_inbox_email`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []
        if 'timeout_millis' in local_var_params and local_var_params['timeout_millis'] is not None:  # noqa: E501
            query_params.append(('timeoutMillis', local_var_params['timeout_millis']))  # noqa: E501
        if 'unread_only' in local_var_params and local_var_params['unread_only'] is not None:  # noqa: E501
            query_params.append(('unreadOnly', local_var_params['unread_only']))  # noqa: E501
        if 'since' in local_var_params and local_var_params['since'] is not None:  # noqa: E501
            query_params.append(('since', local_var_params['since']))  # noqa: E501
        if 'before' in local_var_params and local_var_params['before'] is not None:  # noqa: E501
            query_params.append(('before', local_var_params['before']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/inboxes/{inboxId}/emails/latest', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Email',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_next_work_item(self, get_next_agent_work_item_options, **kwargs):  # noqa: E501
        """Claim the next conversation work item  # noqa: E501

        Selects the oldest available scoped conversation and atomically claims it for one worker. This combines queue selection and claim acquisition so concurrent workers do not need to coordinate those steps themselves.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_next_work_item(get_next_agent_work_item_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param GetNextAgentWorkItemOptions get_next_agent_work_item_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentWorkItemDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_next_work_item_with_http_info(get_next_agent_work_item_options, **kwargs)  # noqa: E501

    def agent_get_next_work_item_with_http_info(self, get_next_agent_work_item_options, **kwargs):  # noqa: E501
        """Claim the next conversation work item  # noqa: E501

        Selects the oldest available scoped conversation and atomically claims it for one worker. This combines queue selection and claim acquisition so concurrent workers do not need to coordinate those steps themselves.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_next_work_item_with_http_info(get_next_agent_work_item_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param GetNextAgentWorkItemOptions get_next_agent_work_item_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentWorkItemDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'get_next_agent_work_item_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_next_work_item" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'get_next_agent_work_item_options' is set
        if self.api_client.client_side_validation and ('get_next_agent_work_item_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['get_next_agent_work_item_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `get_next_agent_work_item_options` when calling `agent_get_next_work_item`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'get_next_agent_work_item_options' in local_var_params:
            body_params = local_var_params['get_next_agent_work_item_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/work-items/next', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentWorkItemDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_phone_message_thread_items(self, phone_number_id, other_phone_number, **kwargs):  # noqa: E501
        """List SMS thread messages  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_phone_message_thread_items(phone_number_id, other_phone_number, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param str other_phone_number: Other participant phone number in E.164 format (required)
        :param int page:
        :param int size:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: PagePhoneMessageThreadItemProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_phone_message_thread_items_with_http_info(phone_number_id, other_phone_number, **kwargs)  # noqa: E501

    def agent_get_phone_message_thread_items_with_http_info(self, phone_number_id, other_phone_number, **kwargs):  # noqa: E501
        """List SMS thread messages  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_phone_message_thread_items_with_http_info(phone_number_id, other_phone_number, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param str other_phone_number: Other participant phone number in E.164 format (required)
        :param int page:
        :param int size:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(PagePhoneMessageThreadItemProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'phone_number_id',
            'other_phone_number',
            'page',
            'size'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_phone_message_thread_items" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'phone_number_id' is set
        if self.api_client.client_side_validation and ('phone_number_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['phone_number_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `phone_number_id` when calling `agent_get_phone_message_thread_items`")  # noqa: E501
        # verify the required parameter 'other_phone_number' is set
        if self.api_client.client_side_validation and ('other_phone_number' not in local_var_params or  # noqa: E501
                                                        local_var_params['other_phone_number'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `other_phone_number` when calling `agent_get_phone_message_thread_items`")  # noqa: E501

        if self.api_client.client_side_validation and 'page' in local_var_params and local_var_params['page'] < 0:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `page` when calling `agent_get_phone_message_thread_items`, must be a value greater than or equal to `0`")  # noqa: E501
        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_get_phone_message_thread_items`, must be a value less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] < 1:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_get_phone_message_thread_items`, must be a value greater than or equal to `1`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'phone_number_id' in local_var_params:
            path_params['phoneNumberId'] = local_var_params['phone_number_id']  # noqa: E501
        if 'other_phone_number' in local_var_params:
            path_params['otherPhoneNumber'] = local_var_params['other_phone_number']  # noqa: E501

        query_params = []
        if 'page' in local_var_params and local_var_params['page'] is not None:  # noqa: E501
            query_params.append(('page', local_var_params['page']))  # noqa: E501
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/phone-numbers/{phoneNumberId}/message-threads/{otherPhoneNumber}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PagePhoneMessageThreadItemProjection',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_phone_message_threads(self, phone_number_id, **kwargs):  # noqa: E501
        """List SMS threads  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_phone_message_threads(phone_number_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param int page:
        :param int size:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: PagePhoneMessageThreadProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_phone_message_threads_with_http_info(phone_number_id, **kwargs)  # noqa: E501

    def agent_get_phone_message_threads_with_http_info(self, phone_number_id, **kwargs):  # noqa: E501
        """List SMS threads  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_phone_message_threads_with_http_info(phone_number_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param int page:
        :param int size:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(PagePhoneMessageThreadProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'phone_number_id',
            'page',
            'size'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_phone_message_threads" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'phone_number_id' is set
        if self.api_client.client_side_validation and ('phone_number_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['phone_number_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `phone_number_id` when calling `agent_get_phone_message_threads`")  # noqa: E501

        if self.api_client.client_side_validation and 'page' in local_var_params and local_var_params['page'] < 0:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `page` when calling `agent_get_phone_message_threads`, must be a value greater than or equal to `0`")  # noqa: E501
        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_get_phone_message_threads`, must be a value less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] < 1:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_get_phone_message_threads`, must be a value greater than or equal to `1`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'phone_number_id' in local_var_params:
            path_params['phoneNumberId'] = local_var_params['phone_number_id']  # noqa: E501

        query_params = []
        if 'page' in local_var_params and local_var_params['page'] is not None:  # noqa: E501
            query_params.append(('page', local_var_params['page']))  # noqa: E501
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/phone-numbers/{phoneNumberId}/message-threads', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PagePhoneMessageThreadProjection',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_phone_number(self, phone_number_id, **kwargs):  # noqa: E501
        """Get an assigned phone number  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_phone_number(phone_number_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: PhoneNumberDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_phone_number_with_http_info(phone_number_id, **kwargs)  # noqa: E501

    def agent_get_phone_number_with_http_info(self, phone_number_id, **kwargs):  # noqa: E501
        """Get an assigned phone number  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_phone_number_with_http_info(phone_number_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(PhoneNumberDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'phone_number_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_phone_number" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'phone_number_id' is set
        if self.api_client.client_side_validation and ('phone_number_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['phone_number_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `phone_number_id` when calling `agent_get_phone_number`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'phone_number_id' in local_var_params:
            path_params['phoneNumberId'] = local_var_params['phone_number_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/phone-numbers/{phoneNumberId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PhoneNumberDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_phone_numbers(self, **kwargs):  # noqa: E501
        """List assigned phone numbers  # noqa: E501

        Returns only active phone numbers explicitly assigned to this agent connection.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_phone_numbers(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page:
        :param int size:
        :param str sort:
        :param str search:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: PageAgentPhoneNumber
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_phone_numbers_with_http_info(**kwargs)  # noqa: E501

    def agent_get_phone_numbers_with_http_info(self, **kwargs):  # noqa: E501
        """List assigned phone numbers  # noqa: E501

        Returns only active phone numbers explicitly assigned to this agent connection.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_phone_numbers_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page:
        :param int size:
        :param str sort:
        :param str search:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(PageAgentPhoneNumber, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            'search'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_phone_numbers" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        if self.api_client.client_side_validation and 'page' in local_var_params and local_var_params['page'] < 0:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `page` when calling `agent_get_phone_numbers`, must be a value greater than or equal to `0`")  # noqa: E501
        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_get_phone_numbers`, must be a value less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] < 1:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_get_phone_numbers`, must be a value greater than or equal to `1`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'page' in local_var_params and local_var_params['page'] is not None:  # noqa: E501
            query_params.append(('page', local_var_params['page']))  # noqa: E501
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501
        if 'sort' in local_var_params and local_var_params['sort'] is not None:  # noqa: E501
            query_params.append(('sort', local_var_params['sort']))  # noqa: E501
        if 'search' in local_var_params and local_var_params['search'] is not None:  # noqa: E501
            query_params.append(('search', local_var_params['search']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/phone-numbers', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageAgentPhoneNumber',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_received_sms_message(self, phone_number_id, sms_id, **kwargs):  # noqa: E501
        """Get received SMS  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_received_sms_message(phone_number_id, sms_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param str sms_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: SmsDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_received_sms_message_with_http_info(phone_number_id, sms_id, **kwargs)  # noqa: E501

    def agent_get_received_sms_message_with_http_info(self, phone_number_id, sms_id, **kwargs):  # noqa: E501
        """Get received SMS  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_received_sms_message_with_http_info(phone_number_id, sms_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param str sms_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(SmsDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'phone_number_id',
            'sms_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_received_sms_message" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'phone_number_id' is set
        if self.api_client.client_side_validation and ('phone_number_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['phone_number_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `phone_number_id` when calling `agent_get_received_sms_message`")  # noqa: E501
        # verify the required parameter 'sms_id' is set
        if self.api_client.client_side_validation and ('sms_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['sms_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `sms_id` when calling `agent_get_received_sms_message`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'phone_number_id' in local_var_params:
            path_params['phoneNumberId'] = local_var_params['phone_number_id']  # noqa: E501
        if 'sms_id' in local_var_params:
            path_params['smsId'] = local_var_params['sms_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/phone-numbers/{phoneNumberId}/sms/{smsId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SmsDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_received_sms_messages(self, phone_number_id, **kwargs):  # noqa: E501
        """List received SMS for an assigned phone number  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_received_sms_messages(phone_number_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param int page:
        :param int size:
        :param str sort:
        :param datetime since:
        :param datetime before:
        :param str search:
        :param bool favourite:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: PageSmsProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_received_sms_messages_with_http_info(phone_number_id, **kwargs)  # noqa: E501

    def agent_get_received_sms_messages_with_http_info(self, phone_number_id, **kwargs):  # noqa: E501
        """List received SMS for an assigned phone number  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_received_sms_messages_with_http_info(phone_number_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param int page:
        :param int size:
        :param str sort:
        :param datetime since:
        :param datetime before:
        :param str search:
        :param bool favourite:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(PageSmsProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'phone_number_id',
            'page',
            'size',
            'sort',
            'since',
            'before',
            'search',
            'favourite'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_received_sms_messages" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'phone_number_id' is set
        if self.api_client.client_side_validation and ('phone_number_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['phone_number_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `phone_number_id` when calling `agent_get_received_sms_messages`")  # noqa: E501

        if self.api_client.client_side_validation and 'page' in local_var_params and local_var_params['page'] < 0:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `page` when calling `agent_get_received_sms_messages`, must be a value greater than or equal to `0`")  # noqa: E501
        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_get_received_sms_messages`, must be a value less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] < 1:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_get_received_sms_messages`, must be a value greater than or equal to `1`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'phone_number_id' in local_var_params:
            path_params['phoneNumberId'] = local_var_params['phone_number_id']  # noqa: E501

        query_params = []
        if 'page' in local_var_params and local_var_params['page'] is not None:  # noqa: E501
            query_params.append(('page', local_var_params['page']))  # noqa: E501
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501
        if 'sort' in local_var_params and local_var_params['sort'] is not None:  # noqa: E501
            query_params.append(('sort', local_var_params['sort']))  # noqa: E501
        if 'since' in local_var_params and local_var_params['since'] is not None:  # noqa: E501
            query_params.append(('since', local_var_params['since']))  # noqa: E501
        if 'before' in local_var_params and local_var_params['before'] is not None:  # noqa: E501
            query_params.append(('before', local_var_params['before']))  # noqa: E501
        if 'search' in local_var_params and local_var_params['search'] is not None:  # noqa: E501
            query_params.append(('search', local_var_params['search']))  # noqa: E501
        if 'favourite' in local_var_params and local_var_params['favourite'] is not None:  # noqa: E501
            query_params.append(('favourite', local_var_params['favourite']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/phone-numbers/{phoneNumberId}/sms', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageSmsProjection',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_sent_sms_message(self, phone_number_id, sent_sms_id, **kwargs):  # noqa: E501
        """Get sent SMS  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_sent_sms_message(phone_number_id, sent_sms_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param str sent_sms_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: SentSmsDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_sent_sms_message_with_http_info(phone_number_id, sent_sms_id, **kwargs)  # noqa: E501

    def agent_get_sent_sms_message_with_http_info(self, phone_number_id, sent_sms_id, **kwargs):  # noqa: E501
        """Get sent SMS  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_sent_sms_message_with_http_info(phone_number_id, sent_sms_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param str sent_sms_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(SentSmsDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'phone_number_id',
            'sent_sms_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_sent_sms_message" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'phone_number_id' is set
        if self.api_client.client_side_validation and ('phone_number_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['phone_number_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `phone_number_id` when calling `agent_get_sent_sms_message`")  # noqa: E501
        # verify the required parameter 'sent_sms_id' is set
        if self.api_client.client_side_validation and ('sent_sms_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['sent_sms_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `sent_sms_id` when calling `agent_get_sent_sms_message`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'phone_number_id' in local_var_params:
            path_params['phoneNumberId'] = local_var_params['phone_number_id']  # noqa: E501
        if 'sent_sms_id' in local_var_params:
            path_params['sentSmsId'] = local_var_params['sent_sms_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/phone-numbers/{phoneNumberId}/sms/sent/{sentSmsId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SentSmsDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_sent_sms_messages(self, phone_number_id, **kwargs):  # noqa: E501
        """List sent SMS for an assigned phone number  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_sent_sms_messages(phone_number_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param int page:
        :param int size:
        :param str sort:
        :param datetime since:
        :param datetime before:
        :param str search:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: PageSentSmsProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_sent_sms_messages_with_http_info(phone_number_id, **kwargs)  # noqa: E501

    def agent_get_sent_sms_messages_with_http_info(self, phone_number_id, **kwargs):  # noqa: E501
        """List sent SMS for an assigned phone number  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_sent_sms_messages_with_http_info(phone_number_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param int page:
        :param int size:
        :param str sort:
        :param datetime since:
        :param datetime before:
        :param str search:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(PageSentSmsProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'phone_number_id',
            'page',
            'size',
            'sort',
            'since',
            'before',
            'search'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_sent_sms_messages" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'phone_number_id' is set
        if self.api_client.client_side_validation and ('phone_number_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['phone_number_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `phone_number_id` when calling `agent_get_sent_sms_messages`")  # noqa: E501

        if self.api_client.client_side_validation and 'page' in local_var_params and local_var_params['page'] < 0:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `page` when calling `agent_get_sent_sms_messages`, must be a value greater than or equal to `0`")  # noqa: E501
        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_get_sent_sms_messages`, must be a value less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] < 1:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_get_sent_sms_messages`, must be a value greater than or equal to `1`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'phone_number_id' in local_var_params:
            path_params['phoneNumberId'] = local_var_params['phone_number_id']  # noqa: E501

        query_params = []
        if 'page' in local_var_params and local_var_params['page'] is not None:  # noqa: E501
            query_params.append(('page', local_var_params['page']))  # noqa: E501
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501
        if 'sort' in local_var_params and local_var_params['sort'] is not None:  # noqa: E501
            query_params.append(('sort', local_var_params['sort']))  # noqa: E501
        if 'since' in local_var_params and local_var_params['since'] is not None:  # noqa: E501
            query_params.append(('since', local_var_params['since']))  # noqa: E501
        if 'before' in local_var_params and local_var_params['before'] is not None:  # noqa: E501
            query_params.append(('before', local_var_params['before']))  # noqa: E501
        if 'search' in local_var_params and local_var_params['search'] is not None:  # noqa: E501
            query_params.append(('search', local_var_params['search']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/phone-numbers/{phoneNumberId}/sms/sent', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageSentSmsProjection',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_sms_conversation(self, conversation_id, **kwargs):  # noqa: E501
        """Get one SMS conversation  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_sms_conversation(conversation_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentSmsConversationDetailDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_sms_conversation_with_http_info(conversation_id, **kwargs)  # noqa: E501

    def agent_get_sms_conversation_with_http_info(self, conversation_id, **kwargs):  # noqa: E501
        """Get one SMS conversation  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_sms_conversation_with_http_info(conversation_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentSmsConversationDetailDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'conversation_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_sms_conversation" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'conversation_id' is set
        if self.api_client.client_side_validation and ('conversation_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['conversation_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `conversation_id` when calling `agent_get_sms_conversation`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'conversation_id' in local_var_params:
            path_params['conversationId'] = local_var_params['conversation_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/sms-conversations/{conversationId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentSmsConversationDetailDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_totp_device(self, id, **kwargs):  # noqa: E501
        """Get an agent-accessible TOTP device  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_totp_device(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: TotpDeviceDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_totp_device_with_http_info(id, **kwargs)  # noqa: E501

    def agent_get_totp_device_with_http_info(self, id, **kwargs):  # noqa: E501
        """Get an agent-accessible TOTP device  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_totp_device_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(TotpDeviceDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_totp_device" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `agent_get_totp_device`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/totp/devices/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TotpDeviceDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_totp_device_by(self, **kwargs):  # noqa: E501
        """Find an agent-accessible TOTP device by name, issuer, or username  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_totp_device_by(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str name:
        :param str issuer:
        :param str username:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: TotpDeviceOptionalDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_totp_device_by_with_http_info(**kwargs)  # noqa: E501

    def agent_get_totp_device_by_with_http_info(self, **kwargs):  # noqa: E501
        """Find an agent-accessible TOTP device by name, issuer, or username  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_totp_device_by_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str name:
        :param str issuer:
        :param str username:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(TotpDeviceOptionalDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'name',
            'issuer',
            'username'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_totp_device_by" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'name' in local_var_params and local_var_params['name'] is not None:  # noqa: E501
            query_params.append(('name', local_var_params['name']))  # noqa: E501
        if 'issuer' in local_var_params and local_var_params['issuer'] is not None:  # noqa: E501
            query_params.append(('issuer', local_var_params['issuer']))  # noqa: E501
        if 'username' in local_var_params and local_var_params['username'] is not None:  # noqa: E501
            query_params.append(('username', local_var_params['username']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/totp/devices/by', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TotpDeviceOptionalDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_get_totp_devices(self, **kwargs):  # noqa: E501
        """List agent-accessible TOTP devices  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_totp_devices(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page:
        :param int size:
        :param str sort:
        :param str issuer:
        :param str username:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: PageTotpDeviceProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_get_totp_devices_with_http_info(**kwargs)  # noqa: E501

    def agent_get_totp_devices_with_http_info(self, **kwargs):  # noqa: E501
        """List agent-accessible TOTP devices  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_get_totp_devices_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page:
        :param int size:
        :param str sort:
        :param str issuer:
        :param str username:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(PageTotpDeviceProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            'issuer',
            'username'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_get_totp_devices" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_get_totp_devices`, must be a value less than or equal to `100`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'page' in local_var_params and local_var_params['page'] is not None:  # noqa: E501
            query_params.append(('page', local_var_params['page']))  # noqa: E501
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501
        if 'sort' in local_var_params and local_var_params['sort'] is not None:  # noqa: E501
            query_params.append(('sort', local_var_params['sort']))  # noqa: E501
        if 'issuer' in local_var_params and local_var_params['issuer'] is not None:  # noqa: E501
            query_params.append(('issuer', local_var_params['issuer']))  # noqa: E501
        if 'username' in local_var_params and local_var_params['username'] is not None:  # noqa: E501
            query_params.append(('username', local_var_params['username']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/totp/devices', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageTotpDeviceProjection',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_list_accessible_inboxes(self, **kwargs):  # noqa: E501
        """List inboxes accessible to an agent  # noqa: E501

        Returns the inbox IDs, addresses, names, and tags visible to this resource-scoped agent key. Agents should use this endpoint instead of guessing inbox IDs.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_list_accessible_inboxes(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int size:
        :param str sort:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AccessibleInboxList
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_list_accessible_inboxes_with_http_info(**kwargs)  # noqa: E501

    def agent_list_accessible_inboxes_with_http_info(self, **kwargs):  # noqa: E501
        """List inboxes accessible to an agent  # noqa: E501

        Returns the inbox IDs, addresses, names, and tags visible to this resource-scoped agent key. Agents should use this endpoint instead of guessing inbox IDs.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_list_accessible_inboxes_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int size:
        :param str sort:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AccessibleInboxList, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'size',
            'sort'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_list_accessible_inboxes" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_list_accessible_inboxes`, must be a value less than or equal to `100`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501
        if 'sort' in local_var_params and local_var_params['sort'] is not None:  # noqa: E501
            query_params.append(('sort', local_var_params['sort']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/inboxes', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AccessibleInboxList',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_list_automation_events(self, **kwargs):  # noqa: E501
        """Read durable scoped automation events  # noqa: E501

        Returns an ordered at-least-once event batch. Persist nextCursor after processing and deduplicate by eventId. waitSeconds enables bounded long polling; production workers should not continuously call latest-email polling.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_list_automation_events(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str cursor:
        :param list[str] event_type:
        :param int size:
        :param int wait_seconds:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentAutomationEventPageDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_list_automation_events_with_http_info(**kwargs)  # noqa: E501

    def agent_list_automation_events_with_http_info(self, **kwargs):  # noqa: E501
        """Read durable scoped automation events  # noqa: E501

        Returns an ordered at-least-once event batch. Persist nextCursor after processing and deduplicate by eventId. waitSeconds enables bounded long polling; production workers should not continuously call latest-email polling.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_list_automation_events_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str cursor:
        :param list[str] event_type:
        :param int size:
        :param int wait_seconds:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentAutomationEventPageDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'cursor',
            'event_type',
            'size',
            'wait_seconds'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_list_automation_events" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_list_automation_events`, must be a value less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and 'wait_seconds' in local_var_params and local_var_params['wait_seconds'] > 30:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `wait_seconds` when calling `agent_list_automation_events`, must be a value less than or equal to `30`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'cursor' in local_var_params and local_var_params['cursor'] is not None:  # noqa: E501
            query_params.append(('cursor', local_var_params['cursor']))  # noqa: E501
        if 'event_type' in local_var_params and local_var_params['event_type'] is not None:  # noqa: E501
            query_params.append(('eventType', local_var_params['event_type']))  # noqa: E501
            collection_formats['eventType'] = 'multi'  # noqa: E501
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501
        if 'wait_seconds' in local_var_params and local_var_params['wait_seconds'] is not None:  # noqa: E501
            query_params.append(('waitSeconds', local_var_params['wait_seconds']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/events', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentAutomationEventPageDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_list_conversations_v2(self, **kwargs):  # noqa: E501
        """List active conversations with an opaque keyset cursor  # noqa: E501

        Reads the bounded mail-thread projection and applies current connection scope on every request. Persist nextCursor only after processing the returned page. Exact totals are intentionally omitted.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_list_conversations_v2(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str workflow_state:
        :param str outcome:
        :param str review_status:
        :param str inbox_id:
        :param bool unread:
        :param bool has_attachments:
        :param datetime since:
        :param datetime before:
        :param str search:
        :param str sort:
        :param str cursor:
        :param int size:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentConversationCursorPageDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_list_conversations_v2_with_http_info(**kwargs)  # noqa: E501

    def agent_list_conversations_v2_with_http_info(self, **kwargs):  # noqa: E501
        """List active conversations with an opaque keyset cursor  # noqa: E501

        Reads the bounded mail-thread projection and applies current connection scope on every request. Persist nextCursor only after processing the returned page. Exact totals are intentionally omitted.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_list_conversations_v2_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str workflow_state:
        :param str outcome:
        :param str review_status:
        :param str inbox_id:
        :param bool unread:
        :param bool has_attachments:
        :param datetime since:
        :param datetime before:
        :param str search:
        :param str sort:
        :param str cursor:
        :param int size:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentConversationCursorPageDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'workflow_state',
            'outcome',
            'review_status',
            'inbox_id',
            'unread',
            'has_attachments',
            'since',
            'before',
            'search',
            'sort',
            'cursor',
            'size'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_list_conversations_v2" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_list_conversations_v2`, must be a value less than or equal to `100`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'workflow_state' in local_var_params and local_var_params['workflow_state'] is not None:  # noqa: E501
            query_params.append(('workflowState', local_var_params['workflow_state']))  # noqa: E501
        if 'outcome' in local_var_params and local_var_params['outcome'] is not None:  # noqa: E501
            query_params.append(('outcome', local_var_params['outcome']))  # noqa: E501
        if 'review_status' in local_var_params and local_var_params['review_status'] is not None:  # noqa: E501
            query_params.append(('reviewStatus', local_var_params['review_status']))  # noqa: E501
        if 'inbox_id' in local_var_params and local_var_params['inbox_id'] is not None:  # noqa: E501
            query_params.append(('inboxId', local_var_params['inbox_id']))  # noqa: E501
        if 'unread' in local_var_params and local_var_params['unread'] is not None:  # noqa: E501
            query_params.append(('unread', local_var_params['unread']))  # noqa: E501
        if 'has_attachments' in local_var_params and local_var_params['has_attachments'] is not None:  # noqa: E501
            query_params.append(('hasAttachments', local_var_params['has_attachments']))  # noqa: E501
        if 'since' in local_var_params and local_var_params['since'] is not None:  # noqa: E501
            query_params.append(('since', local_var_params['since']))  # noqa: E501
        if 'before' in local_var_params and local_var_params['before'] is not None:  # noqa: E501
            query_params.append(('before', local_var_params['before']))  # noqa: E501
        if 'search' in local_var_params and local_var_params['search'] is not None:  # noqa: E501
            query_params.append(('search', local_var_params['search']))  # noqa: E501
        if 'sort' in local_var_params and local_var_params['sort'] is not None:  # noqa: E501
            query_params.append(('sort', local_var_params['sort']))  # noqa: E501
        if 'cursor' in local_var_params and local_var_params['cursor'] is not None:  # noqa: E501
            query_params.append(('cursor', local_var_params['cursor']))  # noqa: E501
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/conversations', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentConversationCursorPageDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_list_email_attachments(self, email_id, **kwargs):  # noqa: E501
        """List attachments on a scoped email for an agent  # noqa: E501

        Returns bounded attachment metadata only after verifying the email belongs to an inbox visible to the agent key.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_list_email_attachments(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: list[AttachmentMetaData]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_list_email_attachments_with_http_info(email_id, **kwargs)  # noqa: E501

    def agent_list_email_attachments_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """List attachments on a scoped email for an agent  # noqa: E501

        Returns bounded attachment metadata only after verifying the email belongs to an inbox visible to the agent key.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_list_email_attachments_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(list[AttachmentMetaData], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_list_email_attachments" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `agent_list_email_attachments`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/emails/{emailId}/attachments', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[AttachmentMetaData]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_list_email_drafts(self, inbox_id, **kwargs):  # noqa: E501
        """List scoped email drafts for an agent  # noqa: E501

        Lists draft previews for one scoped inbox.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_list_email_drafts(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox to list drafts for (required)
        :param int page: Optional page index in draft pagination
        :param int size: Optional page size in draft pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: PageEmailDraftProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_list_email_drafts_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def agent_list_email_drafts_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """List scoped email drafts for an agent  # noqa: E501

        Lists draft previews for one scoped inbox.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_list_email_drafts_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox to list drafts for (required)
        :param int page: Optional page index in draft pagination
        :param int size: Optional page size in draft pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(PageEmailDraftProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_list_email_drafts" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `agent_list_email_drafts`")  # noqa: E501

        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_list_email_drafts`, must be a value less than or equal to `100`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []
        if 'page' in local_var_params and local_var_params['page'] is not None:  # noqa: E501
            query_params.append(('page', local_var_params['page']))  # noqa: E501
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501
        if 'sort' in local_var_params and local_var_params['sort'] is not None:  # noqa: E501
            query_params.append(('sort', local_var_params['sort']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/inboxes/{inboxId}/drafts', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageEmailDraftProjection',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_list_inbox_emails(self, inbox_id, **kwargs):  # noqa: E501
        """List scoped inbox emails for an agent  # noqa: E501

        Returns paginated email previews for one inbox after checking the agent key has AGENT_READ_EMAIL and is scoped to the inbox.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_list_inbox_emails(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox the agent may read (required)
        :param int page: Optional page index in inbox emails list pagination
        :param int size: Optional page size in inbox emails list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Optional filter by received after given date time
        :param datetime before: Optional filter by received before given date time
        :param bool sync_connectors: Sync connectors before fetching emails
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: PageEmailPreview
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_list_inbox_emails_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def agent_list_inbox_emails_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """List scoped inbox emails for an agent  # noqa: E501

        Returns paginated email previews for one inbox after checking the agent key has AGENT_READ_EMAIL and is scoped to the inbox.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_list_inbox_emails_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox the agent may read (required)
        :param int page: Optional page index in inbox emails list pagination
        :param int size: Optional page size in inbox emails list pagination
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param datetime since: Optional filter by received after given date time
        :param datetime before: Optional filter by received before given date time
        :param bool sync_connectors: Sync connectors before fetching emails
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(PageEmailPreview, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort',
            'since',
            'before',
            'sync_connectors'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_list_inbox_emails" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `agent_list_inbox_emails`")  # noqa: E501

        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_list_inbox_emails`, must be a value less than or equal to `100`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []
        if 'page' in local_var_params and local_var_params['page'] is not None:  # noqa: E501
            query_params.append(('page', local_var_params['page']))  # noqa: E501
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501
        if 'sort' in local_var_params and local_var_params['sort'] is not None:  # noqa: E501
            query_params.append(('sort', local_var_params['sort']))  # noqa: E501
        if 'since' in local_var_params and local_var_params['since'] is not None:  # noqa: E501
            query_params.append(('since', local_var_params['since']))  # noqa: E501
        if 'before' in local_var_params and local_var_params['before'] is not None:  # noqa: E501
            query_params.append(('before', local_var_params['before']))  # noqa: E501
        if 'sync_connectors' in local_var_params and local_var_params['sync_connectors'] is not None:  # noqa: E501
            query_params.append(('syncConnectors', local_var_params['sync_connectors']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/inboxes/{inboxId}/emails', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageEmailPreview',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_list_inbox_threads(self, inbox_id, **kwargs):  # noqa: E501
        """List scoped inbox threads for an agent  # noqa: E501

        Lists conversation threads for one scoped inbox, including unread state, attachment presence, message count, and latest-message excerpts.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_list_inbox_threads(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param int page:
        :param int size:
        :param str sort:
        :param str search:
        :param datetime since:
        :param datetime before:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: PageEmailThreadProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_list_inbox_threads_with_http_info(inbox_id, **kwargs)  # noqa: E501

    def agent_list_inbox_threads_with_http_info(self, inbox_id, **kwargs):  # noqa: E501
        """List scoped inbox threads for an agent  # noqa: E501

        Lists conversation threads for one scoped inbox, including unread state, attachment presence, message count, and latest-message excerpts.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_list_inbox_threads_with_http_info(inbox_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param int page:
        :param int size:
        :param str sort:
        :param str search:
        :param datetime since:
        :param datetime before:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(PageEmailThreadProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'page',
            'size',
            'sort',
            'search',
            'since',
            'before'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_list_inbox_threads" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `agent_list_inbox_threads`")  # noqa: E501

        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] > 20:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_list_inbox_threads`, must be a value less than or equal to `20`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []
        if 'page' in local_var_params and local_var_params['page'] is not None:  # noqa: E501
            query_params.append(('page', local_var_params['page']))  # noqa: E501
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501
        if 'sort' in local_var_params and local_var_params['sort'] is not None:  # noqa: E501
            query_params.append(('sort', local_var_params['sort']))  # noqa: E501
        if 'search' in local_var_params and local_var_params['search'] is not None:  # noqa: E501
            query_params.append(('search', local_var_params['search']))  # noqa: E501
        if 'since' in local_var_params and local_var_params['since'] is not None:  # noqa: E501
            query_params.append(('since', local_var_params['since']))  # noqa: E501
        if 'before' in local_var_params and local_var_params['before'] is not None:  # noqa: E501
            query_params.append(('before', local_var_params['before']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/inboxes/{inboxId}/threads', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageEmailThreadProjection',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_list_sms_conversations(self, **kwargs):  # noqa: E501
        """List active SMS conversations  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_list_sms_conversations(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str workflow_state:
        :param str outcome:
        :param str review_status:
        :param str phone_number_id:
        :param bool unread:
        :param bool has_media:
        :param datetime since:
        :param datetime before:
        :param str search:
        :param str sort:
        :param str cursor:
        :param int size:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentSmsConversationCursorPageDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_list_sms_conversations_with_http_info(**kwargs)  # noqa: E501

    def agent_list_sms_conversations_with_http_info(self, **kwargs):  # noqa: E501
        """List active SMS conversations  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_list_sms_conversations_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str workflow_state:
        :param str outcome:
        :param str review_status:
        :param str phone_number_id:
        :param bool unread:
        :param bool has_media:
        :param datetime since:
        :param datetime before:
        :param str search:
        :param str sort:
        :param str cursor:
        :param int size:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentSmsConversationCursorPageDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'workflow_state',
            'outcome',
            'review_status',
            'phone_number_id',
            'unread',
            'has_media',
            'since',
            'before',
            'search',
            'sort',
            'cursor',
            'size'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_list_sms_conversations" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_list_sms_conversations`, must be a value less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] < 1:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_list_sms_conversations`, must be a value greater than or equal to `1`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'workflow_state' in local_var_params and local_var_params['workflow_state'] is not None:  # noqa: E501
            query_params.append(('workflowState', local_var_params['workflow_state']))  # noqa: E501
        if 'outcome' in local_var_params and local_var_params['outcome'] is not None:  # noqa: E501
            query_params.append(('outcome', local_var_params['outcome']))  # noqa: E501
        if 'review_status' in local_var_params and local_var_params['review_status'] is not None:  # noqa: E501
            query_params.append(('reviewStatus', local_var_params['review_status']))  # noqa: E501
        if 'phone_number_id' in local_var_params and local_var_params['phone_number_id'] is not None:  # noqa: E501
            query_params.append(('phoneNumberId', local_var_params['phone_number_id']))  # noqa: E501
        if 'unread' in local_var_params and local_var_params['unread'] is not None:  # noqa: E501
            query_params.append(('unread', local_var_params['unread']))  # noqa: E501
        if 'has_media' in local_var_params and local_var_params['has_media'] is not None:  # noqa: E501
            query_params.append(('hasMedia', local_var_params['has_media']))  # noqa: E501
        if 'since' in local_var_params and local_var_params['since'] is not None:  # noqa: E501
            query_params.append(('since', local_var_params['since']))  # noqa: E501
        if 'before' in local_var_params and local_var_params['before'] is not None:  # noqa: E501
            query_params.append(('before', local_var_params['before']))  # noqa: E501
        if 'search' in local_var_params and local_var_params['search'] is not None:  # noqa: E501
            query_params.append(('search', local_var_params['search']))  # noqa: E501
        if 'sort' in local_var_params and local_var_params['sort'] is not None:  # noqa: E501
            query_params.append(('sort', local_var_params['sort']))  # noqa: E501
        if 'cursor' in local_var_params and local_var_params['cursor'] is not None:  # noqa: E501
            query_params.append(('cursor', local_var_params['cursor']))  # noqa: E501
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/sms-conversations', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentSmsConversationCursorPageDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_prepare_work_item_reply(self, conversation_id, prepare_agent_reply_options, **kwargs):  # noqa: E501
        """Prepare a guarded reply draft  # noqa: E501

        Checks that the selected conversation and latest inbound email are still current, then creates a correctly threaded reply draft. An optional internal note records context for human review without sending email.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_prepare_work_item_reply(conversation_id, prepare_agent_reply_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param PrepareAgentReplyOptions prepare_agent_reply_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentPreparedReplyDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_prepare_work_item_reply_with_http_info(conversation_id, prepare_agent_reply_options, **kwargs)  # noqa: E501

    def agent_prepare_work_item_reply_with_http_info(self, conversation_id, prepare_agent_reply_options, **kwargs):  # noqa: E501
        """Prepare a guarded reply draft  # noqa: E501

        Checks that the selected conversation and latest inbound email are still current, then creates a correctly threaded reply draft. An optional internal note records context for human review without sending email.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_prepare_work_item_reply_with_http_info(conversation_id, prepare_agent_reply_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param PrepareAgentReplyOptions prepare_agent_reply_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentPreparedReplyDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'conversation_id',
            'prepare_agent_reply_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_prepare_work_item_reply" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'conversation_id' is set
        if self.api_client.client_side_validation and ('conversation_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['conversation_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `conversation_id` when calling `agent_prepare_work_item_reply`")  # noqa: E501
        # verify the required parameter 'prepare_agent_reply_options' is set
        if self.api_client.client_side_validation and ('prepare_agent_reply_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['prepare_agent_reply_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `prepare_agent_reply_options` when calling `agent_prepare_work_item_reply`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'conversation_id' in local_var_params:
            path_params['conversationId'] = local_var_params['conversation_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'prepare_agent_reply_options' in local_var_params:
            body_params = local_var_params['prepare_agent_reply_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/work-items/{conversationId}/prepare-reply', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentPreparedReplyDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_release_conversation_claim(self, conversation_id, claim_id, **kwargs):  # noqa: E501
        """Release a conversation claim  # noqa: E501

        Release is idempotent; repeating it does not fail.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_release_conversation_claim(conversation_id, claim_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param str claim_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_release_conversation_claim_with_http_info(conversation_id, claim_id, **kwargs)  # noqa: E501

    def agent_release_conversation_claim_with_http_info(self, conversation_id, claim_id, **kwargs):  # noqa: E501
        """Release a conversation claim  # noqa: E501

        Release is idempotent; repeating it does not fail.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_release_conversation_claim_with_http_info(conversation_id, claim_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param str claim_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'conversation_id',
            'claim_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_release_conversation_claim" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'conversation_id' is set
        if self.api_client.client_side_validation and ('conversation_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['conversation_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `conversation_id` when calling `agent_release_conversation_claim`")  # noqa: E501
        # verify the required parameter 'claim_id' is set
        if self.api_client.client_side_validation and ('claim_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['claim_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `claim_id` when calling `agent_release_conversation_claim`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'conversation_id' in local_var_params:
            path_params['conversationId'] = local_var_params['conversation_id']  # noqa: E501
        if 'claim_id' in local_var_params:
            path_params['claimId'] = local_var_params['claim_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/conversations/{conversationId}/claims/{claimId}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_release_sms_claim(self, conversation_id, claim_id, **kwargs):  # noqa: E501
        """Release an SMS conversation claim  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_release_sms_claim(conversation_id, claim_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param str claim_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_release_sms_claim_with_http_info(conversation_id, claim_id, **kwargs)  # noqa: E501

    def agent_release_sms_claim_with_http_info(self, conversation_id, claim_id, **kwargs):  # noqa: E501
        """Release an SMS conversation claim  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_release_sms_claim_with_http_info(conversation_id, claim_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param str claim_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'conversation_id',
            'claim_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_release_sms_claim" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'conversation_id' is set
        if self.api_client.client_side_validation and ('conversation_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['conversation_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `conversation_id` when calling `agent_release_sms_claim`")  # noqa: E501
        # verify the required parameter 'claim_id' is set
        if self.api_client.client_side_validation and ('claim_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['claim_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `claim_id` when calling `agent_release_sms_claim`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'conversation_id' in local_var_params:
            path_params['conversationId'] = local_var_params['conversation_id']  # noqa: E501
        if 'claim_id' in local_var_params:
            path_params['claimId'] = local_var_params['claim_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/sms-conversations/{conversationId}/claims/{claimId}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_renew_conversation_claim(self, conversation_id, claim_id, renew_agent_conversation_claim_options, **kwargs):  # noqa: E501
        """Renew a conversation claim  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_renew_conversation_claim(conversation_id, claim_id, renew_agent_conversation_claim_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param str claim_id: (required)
        :param RenewAgentConversationClaimOptions renew_agent_conversation_claim_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentConversationClaimDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_renew_conversation_claim_with_http_info(conversation_id, claim_id, renew_agent_conversation_claim_options, **kwargs)  # noqa: E501

    def agent_renew_conversation_claim_with_http_info(self, conversation_id, claim_id, renew_agent_conversation_claim_options, **kwargs):  # noqa: E501
        """Renew a conversation claim  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_renew_conversation_claim_with_http_info(conversation_id, claim_id, renew_agent_conversation_claim_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param str claim_id: (required)
        :param RenewAgentConversationClaimOptions renew_agent_conversation_claim_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentConversationClaimDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'conversation_id',
            'claim_id',
            'renew_agent_conversation_claim_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_renew_conversation_claim" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'conversation_id' is set
        if self.api_client.client_side_validation and ('conversation_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['conversation_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `conversation_id` when calling `agent_renew_conversation_claim`")  # noqa: E501
        # verify the required parameter 'claim_id' is set
        if self.api_client.client_side_validation and ('claim_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['claim_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `claim_id` when calling `agent_renew_conversation_claim`")  # noqa: E501
        # verify the required parameter 'renew_agent_conversation_claim_options' is set
        if self.api_client.client_side_validation and ('renew_agent_conversation_claim_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['renew_agent_conversation_claim_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `renew_agent_conversation_claim_options` when calling `agent_renew_conversation_claim`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'conversation_id' in local_var_params:
            path_params['conversationId'] = local_var_params['conversation_id']  # noqa: E501
        if 'claim_id' in local_var_params:
            path_params['claimId'] = local_var_params['claim_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'renew_agent_conversation_claim_options' in local_var_params:
            body_params = local_var_params['renew_agent_conversation_claim_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/conversations/{conversationId}/claims/{claimId}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentConversationClaimDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_renew_sms_claim(self, conversation_id, claim_id, renew_agent_conversation_claim_options, **kwargs):  # noqa: E501
        """Renew an SMS conversation claim  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_renew_sms_claim(conversation_id, claim_id, renew_agent_conversation_claim_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param str claim_id: (required)
        :param RenewAgentConversationClaimOptions renew_agent_conversation_claim_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentConversationClaimDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_renew_sms_claim_with_http_info(conversation_id, claim_id, renew_agent_conversation_claim_options, **kwargs)  # noqa: E501

    def agent_renew_sms_claim_with_http_info(self, conversation_id, claim_id, renew_agent_conversation_claim_options, **kwargs):  # noqa: E501
        """Renew an SMS conversation claim  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_renew_sms_claim_with_http_info(conversation_id, claim_id, renew_agent_conversation_claim_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param str claim_id: (required)
        :param RenewAgentConversationClaimOptions renew_agent_conversation_claim_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentConversationClaimDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'conversation_id',
            'claim_id',
            'renew_agent_conversation_claim_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_renew_sms_claim" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'conversation_id' is set
        if self.api_client.client_side_validation and ('conversation_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['conversation_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `conversation_id` when calling `agent_renew_sms_claim`")  # noqa: E501
        # verify the required parameter 'claim_id' is set
        if self.api_client.client_side_validation and ('claim_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['claim_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `claim_id` when calling `agent_renew_sms_claim`")  # noqa: E501
        # verify the required parameter 'renew_agent_conversation_claim_options' is set
        if self.api_client.client_side_validation and ('renew_agent_conversation_claim_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['renew_agent_conversation_claim_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `renew_agent_conversation_claim_options` when calling `agent_renew_sms_claim`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'conversation_id' in local_var_params:
            path_params['conversationId'] = local_var_params['conversation_id']  # noqa: E501
        if 'claim_id' in local_var_params:
            path_params['claimId'] = local_var_params['claim_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'renew_agent_conversation_claim_options' in local_var_params:
            body_params = local_var_params['renew_agent_conversation_claim_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/sms-conversations/{conversationId}/claims/{claimId}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentConversationClaimDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_reply_to_email(self, email_id, reply_to_email_options, **kwargs):  # noqa: E501
        """Reply to a scoped email as an agent  # noqa: E501

        Sends a reply using the original conversation context after checking AGENT_REPLY_EMAIL and inbox scope.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_reply_to_email(email_id, reply_to_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to reply to (required)
        :param ReplyToEmailOptions reply_to_email_options: (required)
        :param str idempotency_key:
        :param int expected_conversation_version:
        :param str expected_latest_email_id:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: SentEmailDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_reply_to_email_with_http_info(email_id, reply_to_email_options, **kwargs)  # noqa: E501

    def agent_reply_to_email_with_http_info(self, email_id, reply_to_email_options, **kwargs):  # noqa: E501
        """Reply to a scoped email as an agent  # noqa: E501

        Sends a reply using the original conversation context after checking AGENT_REPLY_EMAIL and inbox scope.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_reply_to_email_with_http_info(email_id, reply_to_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: ID of email to reply to (required)
        :param ReplyToEmailOptions reply_to_email_options: (required)
        :param str idempotency_key:
        :param int expected_conversation_version:
        :param str expected_latest_email_id:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(SentEmailDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'reply_to_email_options',
            'idempotency_key',
            'expected_conversation_version',
            'expected_latest_email_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_reply_to_email" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'email_id' is set
        if self.api_client.client_side_validation and ('email_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['email_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `email_id` when calling `agent_reply_to_email`")  # noqa: E501
        # verify the required parameter 'reply_to_email_options' is set
        if self.api_client.client_side_validation and ('reply_to_email_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['reply_to_email_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `reply_to_email_options` when calling `agent_reply_to_email`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []
        if 'expected_conversation_version' in local_var_params and local_var_params['expected_conversation_version'] is not None:  # noqa: E501
            query_params.append(('expectedConversationVersion', local_var_params['expected_conversation_version']))  # noqa: E501
        if 'expected_latest_email_id' in local_var_params and local_var_params['expected_latest_email_id'] is not None:  # noqa: E501
            query_params.append(('expectedLatestEmailId', local_var_params['expected_latest_email_id']))  # noqa: E501

        header_params = {}
        if 'idempotency_key' in local_var_params:
            header_params['Idempotency-Key'] = local_var_params['idempotency_key']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'reply_to_email_options' in local_var_params:
            body_params = local_var_params['reply_to_email_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/emails/{emailId}/reply', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SentEmailDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_reply_to_sms(self, phone_number_id, sms_id, sms_reply_options, **kwargs):  # noqa: E501
        """Reply to received SMS  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_reply_to_sms(phone_number_id, sms_id, sms_reply_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param str sms_id: (required)
        :param SmsReplyOptions sms_reply_options: (required)
        :param str idempotency_key:
        :param int expected_conversation_version:
        :param str expected_latest_message_id:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: SentSmsDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_reply_to_sms_with_http_info(phone_number_id, sms_id, sms_reply_options, **kwargs)  # noqa: E501

    def agent_reply_to_sms_with_http_info(self, phone_number_id, sms_id, sms_reply_options, **kwargs):  # noqa: E501
        """Reply to received SMS  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_reply_to_sms_with_http_info(phone_number_id, sms_id, sms_reply_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param str sms_id: (required)
        :param SmsReplyOptions sms_reply_options: (required)
        :param str idempotency_key:
        :param int expected_conversation_version:
        :param str expected_latest_message_id:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(SentSmsDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'phone_number_id',
            'sms_id',
            'sms_reply_options',
            'idempotency_key',
            'expected_conversation_version',
            'expected_latest_message_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_reply_to_sms" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'phone_number_id' is set
        if self.api_client.client_side_validation and ('phone_number_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['phone_number_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `phone_number_id` when calling `agent_reply_to_sms`")  # noqa: E501
        # verify the required parameter 'sms_id' is set
        if self.api_client.client_side_validation and ('sms_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['sms_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `sms_id` when calling `agent_reply_to_sms`")  # noqa: E501
        # verify the required parameter 'sms_reply_options' is set
        if self.api_client.client_side_validation and ('sms_reply_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['sms_reply_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `sms_reply_options` when calling `agent_reply_to_sms`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'phone_number_id' in local_var_params:
            path_params['phoneNumberId'] = local_var_params['phone_number_id']  # noqa: E501
        if 'sms_id' in local_var_params:
            path_params['smsId'] = local_var_params['sms_id']  # noqa: E501

        query_params = []
        if 'expected_conversation_version' in local_var_params and local_var_params['expected_conversation_version'] is not None:  # noqa: E501
            query_params.append(('expectedConversationVersion', local_var_params['expected_conversation_version']))  # noqa: E501
        if 'expected_latest_message_id' in local_var_params and local_var_params['expected_latest_message_id'] is not None:  # noqa: E501
            query_params.append(('expectedLatestMessageId', local_var_params['expected_latest_message_id']))  # noqa: E501

        header_params = {}
        if 'idempotency_key' in local_var_params:
            header_params['Idempotency-Key'] = local_var_params['idempotency_key']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'sms_reply_options' in local_var_params:
            body_params = local_var_params['sms_reply_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/phone-numbers/{phoneNumberId}/sms/{smsId}/reply', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SentSmsDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_report_worker_heartbeat(self, agent_worker_heartbeat_options, **kwargs):  # noqa: E501
        """Report a worker heartbeat  # noqa: E501

        Records one running worker instance and its deployed release for owner-side health monitoring. Send this during startup and periodically while the process can accept work; it does not claim or mutate a conversation.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_report_worker_heartbeat(agent_worker_heartbeat_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param AgentWorkerHeartbeatOptions agent_worker_heartbeat_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentWorkerHeartbeatDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_report_worker_heartbeat_with_http_info(agent_worker_heartbeat_options, **kwargs)  # noqa: E501

    def agent_report_worker_heartbeat_with_http_info(self, agent_worker_heartbeat_options, **kwargs):  # noqa: E501
        """Report a worker heartbeat  # noqa: E501

        Records one running worker instance and its deployed release for owner-side health monitoring. Send this during startup and periodically while the process can accept work; it does not claim or mutate a conversation.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_report_worker_heartbeat_with_http_info(agent_worker_heartbeat_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param AgentWorkerHeartbeatOptions agent_worker_heartbeat_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentWorkerHeartbeatDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'agent_worker_heartbeat_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_report_worker_heartbeat" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'agent_worker_heartbeat_options' is set
        if self.api_client.client_side_validation and ('agent_worker_heartbeat_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['agent_worker_heartbeat_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `agent_worker_heartbeat_options` when calling `agent_report_worker_heartbeat`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'agent_worker_heartbeat_options' in local_var_params:
            body_params = local_var_params['agent_worker_heartbeat_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/runtime/heartbeat', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentWorkerHeartbeatDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_request_conversation_handoff(self, conversation_id, create_agent_conversation_handoff_options, **kwargs):  # noqa: E501
        """Request human review for a conversation  # noqa: E501

        Creates or returns the active handoff and moves the shared workflow state into REVIEW without classifying the request as an operational failure.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_request_conversation_handoff(conversation_id, create_agent_conversation_handoff_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param CreateAgentConversationHandoffOptions create_agent_conversation_handoff_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentConversationHandoffDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_request_conversation_handoff_with_http_info(conversation_id, create_agent_conversation_handoff_options, **kwargs)  # noqa: E501

    def agent_request_conversation_handoff_with_http_info(self, conversation_id, create_agent_conversation_handoff_options, **kwargs):  # noqa: E501
        """Request human review for a conversation  # noqa: E501

        Creates or returns the active handoff and moves the shared workflow state into REVIEW without classifying the request as an operational failure.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_request_conversation_handoff_with_http_info(conversation_id, create_agent_conversation_handoff_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param CreateAgentConversationHandoffOptions create_agent_conversation_handoff_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentConversationHandoffDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'conversation_id',
            'create_agent_conversation_handoff_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_request_conversation_handoff" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'conversation_id' is set
        if self.api_client.client_side_validation and ('conversation_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['conversation_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `conversation_id` when calling `agent_request_conversation_handoff`")  # noqa: E501
        # verify the required parameter 'create_agent_conversation_handoff_options' is set
        if self.api_client.client_side_validation and ('create_agent_conversation_handoff_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_agent_conversation_handoff_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_agent_conversation_handoff_options` when calling `agent_request_conversation_handoff`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'conversation_id' in local_var_params:
            path_params['conversationId'] = local_var_params['conversation_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_agent_conversation_handoff_options' in local_var_params:
            body_params = local_var_params['create_agent_conversation_handoff_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/conversations/{conversationId}/handoffs', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentConversationHandoffDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_request_sms_handoff(self, conversation_id, create_agent_sms_conversation_handoff_options, **kwargs):  # noqa: E501
        """Request human review for an SMS conversation  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_request_sms_handoff(conversation_id, create_agent_sms_conversation_handoff_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param CreateAgentSmsConversationHandoffOptions create_agent_sms_conversation_handoff_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: AgentConversationHandoffDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_request_sms_handoff_with_http_info(conversation_id, create_agent_sms_conversation_handoff_options, **kwargs)  # noqa: E501

    def agent_request_sms_handoff_with_http_info(self, conversation_id, create_agent_sms_conversation_handoff_options, **kwargs):  # noqa: E501
        """Request human review for an SMS conversation  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_request_sms_handoff_with_http_info(conversation_id, create_agent_sms_conversation_handoff_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str conversation_id: (required)
        :param CreateAgentSmsConversationHandoffOptions create_agent_sms_conversation_handoff_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(AgentConversationHandoffDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'conversation_id',
            'create_agent_sms_conversation_handoff_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_request_sms_handoff" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'conversation_id' is set
        if self.api_client.client_side_validation and ('conversation_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['conversation_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `conversation_id` when calling `agent_request_sms_handoff`")  # noqa: E501
        # verify the required parameter 'create_agent_sms_conversation_handoff_options' is set
        if self.api_client.client_side_validation and ('create_agent_sms_conversation_handoff_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['create_agent_sms_conversation_handoff_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `create_agent_sms_conversation_handoff_options` when calling `agent_request_sms_handoff`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'conversation_id' in local_var_params:
            path_params['conversationId'] = local_var_params['conversation_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'create_agent_sms_conversation_handoff_options' in local_var_params:
            body_params = local_var_params['create_agent_sms_conversation_handoff_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/sms-conversations/{conversationId}/handoffs', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AgentConversationHandoffDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_search_inbox_emails(self, inbox_id, match_options, **kwargs):  # noqa: E501
        """Search scoped inbox emails for an agent  # noqa: E501

        Searches one scoped inbox using explicit field matches and attachment conditions. Use this for deterministic automation recovery instead of repeatedly fetching the latest message.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_search_inbox_emails(inbox_id, match_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param MatchOptions match_options: (required)
        :param int size:
        :param str sort:
        :param datetime since:
        :param datetime before:
        :param bool unread_only:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: list[EmailPreview]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_search_inbox_emails_with_http_info(inbox_id, match_options, **kwargs)  # noqa: E501

    def agent_search_inbox_emails_with_http_info(self, inbox_id, match_options, **kwargs):  # noqa: E501
        """Search scoped inbox emails for an agent  # noqa: E501

        Searches one scoped inbox using explicit field matches and attachment conditions. Use this for deterministic automation recovery instead of repeatedly fetching the latest message.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_search_inbox_emails_with_http_info(inbox_id, match_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param MatchOptions match_options: (required)
        :param int size:
        :param str sort:
        :param datetime since:
        :param datetime before:
        :param bool unread_only:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(list[EmailPreview], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'match_options',
            'size',
            'sort',
            'since',
            'before',
            'unread_only'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_search_inbox_emails" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `agent_search_inbox_emails`")  # noqa: E501
        # verify the required parameter 'match_options' is set
        if self.api_client.client_side_validation and ('match_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['match_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `match_options` when calling `agent_search_inbox_emails`")  # noqa: E501

        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] > 20:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `agent_search_inbox_emails`, must be a value less than or equal to `20`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501
        if 'sort' in local_var_params and local_var_params['sort'] is not None:  # noqa: E501
            query_params.append(('sort', local_var_params['sort']))  # noqa: E501
        if 'since' in local_var_params and local_var_params['since'] is not None:  # noqa: E501
            query_params.append(('since', local_var_params['since']))  # noqa: E501
        if 'before' in local_var_params and local_var_params['before'] is not None:  # noqa: E501
            query_params.append(('before', local_var_params['before']))  # noqa: E501
        if 'unread_only' in local_var_params and local_var_params['unread_only'] is not None:  # noqa: E501
            query_params.append(('unreadOnly', local_var_params['unread_only']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'match_options' in local_var_params:
            body_params = local_var_params['match_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/inboxes/{inboxId}/emails/search', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[EmailPreview]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_send_email_draft(self, inbox_id, draft_id, **kwargs):  # noqa: E501
        """Send a scoped email draft for an agent  # noqa: E501

        Sends a saved draft through the existing inbox send pipeline and deletes it only after send success.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_send_email_draft(inbox_id, draft_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox the draft belongs to (required)
        :param str draft_id: ID of draft (required)
        :param str idempotency_key:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: SentEmailDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_send_email_draft_with_http_info(inbox_id, draft_id, **kwargs)  # noqa: E501

    def agent_send_email_draft_with_http_info(self, inbox_id, draft_id, **kwargs):  # noqa: E501
        """Send a scoped email draft for an agent  # noqa: E501

        Sends a saved draft through the existing inbox send pipeline and deletes it only after send success.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_send_email_draft_with_http_info(inbox_id, draft_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox the draft belongs to (required)
        :param str draft_id: ID of draft (required)
        :param str idempotency_key:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(SentEmailDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'draft_id',
            'idempotency_key'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_send_email_draft" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `agent_send_email_draft`")  # noqa: E501
        # verify the required parameter 'draft_id' is set
        if self.api_client.client_side_validation and ('draft_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['draft_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `draft_id` when calling `agent_send_email_draft`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501
        if 'draft_id' in local_var_params:
            path_params['draftId'] = local_var_params['draft_id']  # noqa: E501

        query_params = []

        header_params = {}
        if 'idempotency_key' in local_var_params:
            header_params['Idempotency-Key'] = local_var_params['idempotency_key']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/inboxes/{inboxId}/drafts/{draftId}/send', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SentEmailDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_send_sms(self, phone_number_id, sms_send_options, **kwargs):  # noqa: E501
        """Send SMS from an assigned phone number  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_send_sms(phone_number_id, sms_send_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param SmsSendOptions sms_send_options: (required)
        :param str idempotency_key:
        :param int expected_conversation_version:
        :param str expected_latest_message_id:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: SentSmsDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_send_sms_with_http_info(phone_number_id, sms_send_options, **kwargs)  # noqa: E501

    def agent_send_sms_with_http_info(self, phone_number_id, sms_send_options, **kwargs):  # noqa: E501
        """Send SMS from an assigned phone number  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_send_sms_with_http_info(phone_number_id, sms_send_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str phone_number_id: (required)
        :param SmsSendOptions sms_send_options: (required)
        :param str idempotency_key:
        :param int expected_conversation_version:
        :param str expected_latest_message_id:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(SentSmsDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'phone_number_id',
            'sms_send_options',
            'idempotency_key',
            'expected_conversation_version',
            'expected_latest_message_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_send_sms" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'phone_number_id' is set
        if self.api_client.client_side_validation and ('phone_number_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['phone_number_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `phone_number_id` when calling `agent_send_sms`")  # noqa: E501
        # verify the required parameter 'sms_send_options' is set
        if self.api_client.client_side_validation and ('sms_send_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['sms_send_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `sms_send_options` when calling `agent_send_sms`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'phone_number_id' in local_var_params:
            path_params['phoneNumberId'] = local_var_params['phone_number_id']  # noqa: E501

        query_params = []
        if 'expected_conversation_version' in local_var_params and local_var_params['expected_conversation_version'] is not None:  # noqa: E501
            query_params.append(('expectedConversationVersion', local_var_params['expected_conversation_version']))  # noqa: E501
        if 'expected_latest_message_id' in local_var_params and local_var_params['expected_latest_message_id'] is not None:  # noqa: E501
            query_params.append(('expectedLatestMessageId', local_var_params['expected_latest_message_id']))  # noqa: E501

        header_params = {}
        if 'idempotency_key' in local_var_params:
            header_params['Idempotency-Key'] = local_var_params['idempotency_key']  # noqa: E501

        form_params = []
        local_var_files = {}

        body_params = None
        if 'sms_send_options' in local_var_params:
            body_params = local_var_params['sms_send_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/phone-numbers/{phoneNumberId}/sms', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='SentSmsDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_update_email_draft(self, inbox_id, draft_id, send_email_options, **kwargs):  # noqa: E501
        """Update a scoped email draft for an agent  # noqa: E501

        Replaces the SendEmailOptions stored for a draft. The draft remains attached to its original inbox.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_update_email_draft(inbox_id, draft_id, send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox the draft belongs to (required)
        :param str draft_id: ID of draft (required)
        :param SendEmailOptions send_email_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: EmailDraftDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_update_email_draft_with_http_info(inbox_id, draft_id, send_email_options, **kwargs)  # noqa: E501

    def agent_update_email_draft_with_http_info(self, inbox_id, draft_id, send_email_options, **kwargs):  # noqa: E501
        """Update a scoped email draft for an agent  # noqa: E501

        Replaces the SendEmailOptions stored for a draft. The draft remains attached to its original inbox.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_update_email_draft_with_http_info(inbox_id, draft_id, send_email_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: ID of inbox the draft belongs to (required)
        :param str draft_id: ID of draft (required)
        :param SendEmailOptions send_email_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(EmailDraftDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'draft_id',
            'send_email_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_update_email_draft" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `agent_update_email_draft`")  # noqa: E501
        # verify the required parameter 'draft_id' is set
        if self.api_client.client_side_validation and ('draft_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['draft_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `draft_id` when calling `agent_update_email_draft`")  # noqa: E501
        # verify the required parameter 'send_email_options' is set
        if self.api_client.client_side_validation and ('send_email_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['send_email_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `send_email_options` when calling `agent_update_email_draft`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501
        if 'draft_id' in local_var_params:
            path_params['draftId'] = local_var_params['draft_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'send_email_options' in local_var_params:
            body_params = local_var_params['send_email_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/inboxes/{inboxId}/drafts/{draftId}', 'PATCH',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='EmailDraftDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_update_inbox(self, inbox_id, update_inbox_options, **kwargs):  # noqa: E501
        """Update an inbox visible to an inbox-manager connection  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_update_inbox(inbox_id, update_inbox_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param UpdateInboxOptions update_inbox_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: InboxDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_update_inbox_with_http_info(inbox_id, update_inbox_options, **kwargs)  # noqa: E501

    def agent_update_inbox_with_http_info(self, inbox_id, update_inbox_options, **kwargs):  # noqa: E501
        """Update an inbox visible to an inbox-manager connection  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_update_inbox_with_http_info(inbox_id, update_inbox_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str inbox_id: (required)
        :param UpdateInboxOptions update_inbox_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(InboxDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'inbox_id',
            'update_inbox_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_update_inbox" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'inbox_id' is set
        if self.api_client.client_side_validation and ('inbox_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['inbox_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `inbox_id` when calling `agent_update_inbox`")  # noqa: E501
        # verify the required parameter 'update_inbox_options' is set
        if self.api_client.client_side_validation and ('update_inbox_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['update_inbox_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `update_inbox_options` when calling `agent_update_inbox`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'inbox_id' in local_var_params:
            path_params['inboxId'] = local_var_params['inbox_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'update_inbox_options' in local_var_params:
            body_params = local_var_params['update_inbox_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/inboxes/{inboxId}', 'PATCH',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InboxDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def agent_update_totp_device(self, id, update_totp_device_options, **kwargs):  # noqa: E501
        """Update an agent-managed TOTP device  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_update_totp_device(id, update_totp_device_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param UpdateTotpDeviceOptions update_totp_device_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: TotpDeviceDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.agent_update_totp_device_with_http_info(id, update_totp_device_options, **kwargs)  # noqa: E501

    def agent_update_totp_device_with_http_info(self, id, update_totp_device_options, **kwargs):  # noqa: E501
        """Update an agent-managed TOTP device  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.agent_update_totp_device_with_http_info(id, update_totp_device_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: (required)
        :param UpdateTotpDeviceOptions update_totp_device_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(TotpDeviceDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'id',
            'update_totp_device_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method agent_update_totp_device" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `agent_update_totp_device`")  # noqa: E501
        # verify the required parameter 'update_totp_device_options' is set
        if self.api_client.client_side_validation and ('update_totp_device_options' not in local_var_params or  # noqa: E501
                                                        local_var_params['update_totp_device_options'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `update_totp_device_options` when calling `agent_update_totp_device`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'update_totp_device_options' in local_var_params:
            body_params = local_var_params['update_totp_device_options']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['*/*'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['API_KEY']  # noqa: E501

        return self.api_client.call_api(
            '/agent/totp/devices/{id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='TotpDeviceDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

Methods

def agent_acquire_conversation_claim(self, conversation_id, acquire_agent_conversation_claim_options, **kwargs)

Acquire a renewable conversation claim # noqa: E501

Atomically leases a conversation to one worker. A conflict means another unexpired worker owns it. Use expectedVersion to reject work selected from stale context. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_acquire_conversation_claim(conversation_id, acquire_agent_conversation_claim_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param AcquireAgentConversationClaimOptions acquire_agent_conversation_claim_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentConversationClaimDto If the method is called asynchronously, returns the request thread.

def agent_acquire_conversation_claim_with_http_info(self, conversation_id, acquire_agent_conversation_claim_options, **kwargs)

Acquire a renewable conversation claim # noqa: E501

Atomically leases a conversation to one worker. A conflict means another unexpired worker owns it. Use expectedVersion to reject work selected from stale context. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_acquire_conversation_claim_with_http_info(conversation_id, acquire_agent_conversation_claim_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param AcquireAgentConversationClaimOptions acquire_agent_conversation_claim_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentConversationClaimDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_add_conversation_note(self, conversation_id, create_agent_conversation_note_options, **kwargs)

Add an internal conversation note # noqa: E501

Adds agent/operator collaboration context without sending any email to the customer. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_add_conversation_note(conversation_id, create_agent_conversation_note_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param CreateAgentConversationNoteOptions create_agent_conversation_note_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentConversationNoteDto If the method is called asynchronously, returns the request thread.

def agent_add_conversation_note_with_http_info(self, conversation_id, create_agent_conversation_note_options, **kwargs)

Add an internal conversation note # noqa: E501

Adds agent/operator collaboration context without sending any email to the customer. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_add_conversation_note_with_http_info(conversation_id, create_agent_conversation_note_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param CreateAgentConversationNoteOptions create_agent_conversation_note_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentConversationNoteDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_add_sms_note(self, conversation_id, create_agent_sms_conversation_note_options, **kwargs)

Add an internal SMS conversation note # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_add_sms_note(conversation_id, create_agent_sms_conversation_note_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param CreateAgentSmsConversationNoteOptions create_agent_sms_conversation_note_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentConversationNoteDto If the method is called asynchronously, returns the request thread.

def agent_add_sms_note_with_http_info(self, conversation_id, create_agent_sms_conversation_note_options, **kwargs)

Add an internal SMS conversation note # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_add_sms_note_with_http_info(conversation_id, create_agent_sms_conversation_note_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param CreateAgentSmsConversationNoteOptions create_agent_sms_conversation_note_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentConversationNoteDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_check_inbox_send_policy(self, inbox_id, agent_inbox_send_policy_check_options, **kwargs)

Check whether sending rules allow recipients # noqa: E501

Evaluates effective inbox and account sending rules before an agent creates a send action. A blocked result includes the operator recovery route. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_check_inbox_send_policy(inbox_id, agent_inbox_send_policy_check_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: (required) :param AgentInboxSendPolicyCheckOptions agent_inbox_send_policy_check_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentInboxSendPolicyDto If the method is called asynchronously, returns the request thread.

def agent_check_inbox_send_policy_with_http_info(self, inbox_id, agent_inbox_send_policy_check_options, **kwargs)

Check whether sending rules allow recipients # noqa: E501

Evaluates effective inbox and account sending rules before an agent creates a send action. A blocked result includes the operator recovery route. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_check_inbox_send_policy_with_http_info(inbox_id, agent_inbox_send_policy_check_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: (required) :param AgentInboxSendPolicyCheckOptions agent_inbox_send_policy_check_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentInboxSendPolicyDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_claim_sms_conversation(self, conversation_id, acquire_agent_conversation_claim_options, **kwargs)

Acquire an SMS conversation claim # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_claim_sms_conversation(conversation_id, acquire_agent_conversation_claim_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param AcquireAgentConversationClaimOptions acquire_agent_conversation_claim_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentConversationClaimDto If the method is called asynchronously, returns the request thread.

def agent_claim_sms_conversation_with_http_info(self, conversation_id, acquire_agent_conversation_claim_options, **kwargs)

Acquire an SMS conversation claim # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_claim_sms_conversation_with_http_info(conversation_id, acquire_agent_conversation_claim_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param AcquireAgentConversationClaimOptions acquire_agent_conversation_claim_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentConversationClaimDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_complete_work_item(self, conversation_id, complete_agent_work_item_options, **kwargs)

Complete a work item with an idempotent reply # noqa: E501

Revalidates conversation freshness, sends one threaded reply with an idempotency key, and releases the supplied claim only after the send succeeds. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_complete_work_item(conversation_id, complete_agent_work_item_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param CompleteAgentWorkItemOptions complete_agent_work_item_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentCompletedWorkItemDto If the method is called asynchronously, returns the request thread.

def agent_complete_work_item_with_http_info(self, conversation_id, complete_agent_work_item_options, **kwargs)

Complete a work item with an idempotent reply # noqa: E501

Revalidates conversation freshness, sends one threaded reply with an idempotency key, and releases the supplied claim only after the send succeeds. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_complete_work_item_with_http_info(conversation_id, complete_agent_work_item_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param CompleteAgentWorkItemOptions complete_agent_work_item_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentCompletedWorkItemDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_create_email_draft(self, inbox_id, send_email_options, **kwargs)

Create a scoped email draft for an agent # noqa: E501

Creates a saved draft in the path inbox using the same SendEmailOptions shape as sending, without sending the email. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_create_email_draft(inbox_id, send_email_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: ID of inbox to save the draft against (required) :param SendEmailOptions send_email_options: (required) :param str source_email_id: Optional source email this draft responds to. When supplied, MailSlurp links the draft and later draft actions to that conversation. :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: EmailDraftDto If the method is called asynchronously, returns the request thread.

def agent_create_email_draft_with_http_info(self, inbox_id, send_email_options, **kwargs)

Create a scoped email draft for an agent # noqa: E501

Creates a saved draft in the path inbox using the same SendEmailOptions shape as sending, without sending the email. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_create_email_draft_with_http_info(inbox_id, send_email_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: ID of inbox to save the draft against (required) :param SendEmailOptions send_email_options: (required) :param str source_email_id: Optional source email this draft responds to. When supplied, MailSlurp links the draft and later draft actions to that conversation. :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(EmailDraftDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_create_inbox(self, create_inbox_dto, **kwargs)

Create an inbox with an account-wide inbox-manager connection # noqa: E501

Creates an inbox without changing this agent connection's scopes. Account-wide scope is required so the new inbox is already covered. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_create_inbox(create_inbox_dto, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateInboxDto create_inbox_dto: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: InboxDto If the method is called asynchronously, returns the request thread.

def agent_create_inbox_with_http_info(self, create_inbox_dto, **kwargs)

Create an inbox with an account-wide inbox-manager connection # noqa: E501

Creates an inbox without changing this agent connection's scopes. Account-wide scope is required so the new inbox is already covered. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_create_inbox_with_http_info(create_inbox_dto, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateInboxDto create_inbox_dto: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(InboxDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_create_reply_draft(self, email_id, reply_to_email_options, **kwargs)

Create a correctly threaded reply draft # noqa: E501

Builds the same recipients and RFC In-Reply-To/References headers as immediate reply, saves them as a draft, and preserves the required threading headers across later agent draft updates. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_create_reply_draft(email_id, reply_to_email_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: (required) :param ReplyToEmailOptions reply_to_email_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: EmailDraftDto If the method is called asynchronously, returns the request thread.

def agent_create_reply_draft_with_http_info(self, email_id, reply_to_email_options, **kwargs)

Create a correctly threaded reply draft # noqa: E501

Builds the same recipients and RFC In-Reply-To/References headers as immediate reply, saves them as a draft, and preserves the required threading headers across later agent draft updates. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_create_reply_draft_with_http_info(email_id, reply_to_email_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: (required) :param ReplyToEmailOptions reply_to_email_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(EmailDraftDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_create_totp_device_for_base32_secret_key(self, create_totp_device_base32_secret_key_options, **kwargs)

Create an agent-managed TOTP device from a base32 secret key # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_create_totp_device_for_base32_secret_key(create_totp_device_base32_secret_key_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateTotpDeviceBase32SecretKeyOptions create_totp_device_base32_secret_key_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: TotpDeviceDto If the method is called asynchronously, returns the request thread.

def agent_create_totp_device_for_base32_secret_key_with_http_info(self, create_totp_device_base32_secret_key_options, **kwargs)

Create an agent-managed TOTP device from a base32 secret key # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_create_totp_device_for_base32_secret_key_with_http_info(create_totp_device_base32_secret_key_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateTotpDeviceBase32SecretKeyOptions create_totp_device_base32_secret_key_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(TotpDeviceDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_create_totp_device_for_custom(self, create_totp_device_custom_options, **kwargs)

Create an agent-managed TOTP device from custom options # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_create_totp_device_for_custom(create_totp_device_custom_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateTotpDeviceCustomOptions create_totp_device_custom_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: TotpDeviceDto If the method is called asynchronously, returns the request thread.

def agent_create_totp_device_for_custom_with_http_info(self, create_totp_device_custom_options, **kwargs)

Create an agent-managed TOTP device from custom options # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_create_totp_device_for_custom_with_http_info(create_totp_device_custom_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateTotpDeviceCustomOptions create_totp_device_custom_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(TotpDeviceDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_create_totp_device_for_otp_auth_url(self, create_totp_device_otp_auth_url_options, **kwargs)

Create an agent-managed TOTP device from an OTP Auth URL # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_create_totp_device_for_otp_auth_url(create_totp_device_otp_auth_url_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateTotpDeviceOtpAuthUrlOptions create_totp_device_otp_auth_url_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: TotpDeviceDto If the method is called asynchronously, returns the request thread.

def agent_create_totp_device_for_otp_auth_url_with_http_info(self, create_totp_device_otp_auth_url_options, **kwargs)

Create an agent-managed TOTP device from an OTP Auth URL # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_create_totp_device_for_otp_auth_url_with_http_info(create_totp_device_otp_auth_url_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateTotpDeviceOtpAuthUrlOptions create_totp_device_otp_auth_url_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(TotpDeviceDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_defer_work_item(self, conversation_id, defer_agent_work_item_options, **kwargs)

Defer a work item to human review # noqa: E501

Creates or returns the active review handoff and releases the supplied claim after the handoff is durable. Deferral is a normal workflow result rather than an operational failure. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_defer_work_item(conversation_id, defer_agent_work_item_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param DeferAgentWorkItemOptions defer_agent_work_item_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentDeferredWorkItemDto If the method is called asynchronously, returns the request thread.

def agent_defer_work_item_with_http_info(self, conversation_id, defer_agent_work_item_options, **kwargs)

Defer a work item to human review # noqa: E501

Creates or returns the active review handoff and releases the supplied claim after the handoff is durable. Deferral is a normal workflow result rather than an operational failure. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_defer_work_item_with_http_info(conversation_id, defer_agent_work_item_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param DeferAgentWorkItemOptions defer_agent_work_item_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentDeferredWorkItemDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_delete_email_draft(self, inbox_id, draft_id, **kwargs)

Delete a scoped email draft for an agent # noqa: E501

Deletes a saved draft without sending it. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_delete_email_draft(inbox_id, draft_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: ID of inbox the draft belongs to (required) :param str draft_id: ID of draft (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: None If the method is called asynchronously, returns the request thread.

def agent_delete_email_draft_with_http_info(self, inbox_id, draft_id, **kwargs)

Delete a scoped email draft for an agent # noqa: E501

Deletes a saved draft without sending it. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_delete_email_draft_with_http_info(inbox_id, draft_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: ID of inbox the draft belongs to (required) :param str draft_id: ID of draft (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: None If the method is called asynchronously, returns the request thread.

def agent_delete_totp_device(self, id, **kwargs)

Delete an agent-managed TOTP device # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_delete_totp_device(id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: None If the method is called asynchronously, returns the request thread.

def agent_delete_totp_device_with_http_info(self, id, **kwargs)

Delete an agent-managed TOTP device # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_delete_totp_device_with_http_info(id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: None If the method is called asynchronously, returns the request thread.

def agent_extract_email_attachment_text(self, email_id, attachment_id, **kwargs)

Extract text from a scoped email attachment for an agent # noqa: E501

Extracts bounded text only after verifying both the email scope and that the attachment belongs to that email. List attachments first instead of guessing IDs. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_extract_email_attachment_text(email_id, attachment_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: (required) :param str attachment_id: (required) :param ExtractAttachmentTextOptions extract_attachment_text_options: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: ExtractAttachmentTextResult If the method is called asynchronously, returns the request thread.

def agent_extract_email_attachment_text_with_http_info(self, email_id, attachment_id, **kwargs)

Extract text from a scoped email attachment for an agent # noqa: E501

Extracts bounded text only after verifying both the email scope and that the attachment belongs to that email. List attachments first instead of guessing IDs. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_extract_email_attachment_text_with_http_info(email_id, attachment_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: (required) :param str attachment_id: (required) :param ExtractAttachmentTextOptions extract_attachment_text_options: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(ExtractAttachmentTextResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_generate_totp_device_code(self, id, **kwargs)

Generate a code for an agent-managed TOTP device # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_generate_totp_device_code(id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str id: (required) :param datetime at: :param int min_seconds_until_expire: Minimum remaining code lifetime. The request may wait for the next period when needed. :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: TotpDeviceCodeDto If the method is called asynchronously, returns the request thread.

def agent_generate_totp_device_code_with_http_info(self, id, **kwargs)

Generate a code for an agent-managed TOTP device # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_generate_totp_device_code_with_http_info(id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str id: (required) :param datetime at: :param int min_seconds_until_expire: Minimum remaining code lifetime. The request may wait for the next period when needed. :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(TotpDeviceCodeDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_capabilities(self, **kwargs)

Discover this agent connection's capabilities # noqa: E501

Returns the connection identity, role, effective permission names, declared resource scope, feature availability, and server-enforced limits. Call this once during worker startup instead of hard-coding role behavior. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentCapabilitiesDto If the method is called asynchronously, returns the request thread.

def agent_get_capabilities_with_http_info(self, **kwargs)

Discover this agent connection's capabilities # noqa: E501

Returns the connection identity, role, effective permission names, declared resource scope, feature availability, and server-enforced limits. Call this once during worker startup instead of hard-coding role behavior. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentCapabilitiesDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_conversation_v2(self, conversation_id, **kwargs)

Get one scoped conversation # noqa: E501

Returns the projected conversation plus this connection's bounded activity timeline, internal notes, and active human-review handoff. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_conversation_v2(conversation_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentConversationDetailV2Dto If the method is called asynchronously, returns the request thread.

def agent_get_conversation_v2_with_http_info(self, conversation_id, **kwargs)

Get one scoped conversation # noqa: E501

Returns the projected conversation plus this connection's bounded activity timeline, internal notes, and active human-review handoff. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_conversation_v2_with_http_info(conversation_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentConversationDetailV2Dto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_email(self, email_id, **kwargs)

Get scoped hydrated email for an agent # noqa: E501

Returns parsed email content after resolving the message inbox and checking agent scope. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_email(email_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: ID of email to inspect (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Email If the method is called asynchronously, returns the request thread.

def agent_get_email_draft(self, inbox_id, draft_id, **kwargs)

Get a scoped email draft for an agent # noqa: E501

Returns a saved draft including the full SendEmailOptions payload. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_email_draft(inbox_id, draft_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: ID of inbox the draft belongs to (required) :param str draft_id: ID of draft (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: EmailDraftDto If the method is called asynchronously, returns the request thread.

def agent_get_email_draft_with_http_info(self, inbox_id, draft_id, **kwargs)

Get a scoped email draft for an agent # noqa: E501

Returns a saved draft including the full SendEmailOptions payload. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_email_draft_with_http_info(inbox_id, draft_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: ID of inbox the draft belongs to (required) :param str draft_id: ID of draft (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(EmailDraftDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_email_summary(self, email_id, **kwargs)

Get scoped email summary for an agent # noqa: E501

Returns lightweight metadata and headers for an email after resolving its inbox and checking the agent key scope. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_email_summary(email_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: ID of email to inspect (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: EmailPreview If the method is called asynchronously, returns the request thread.

def agent_get_email_summary_with_http_info(self, email_id, **kwargs)

Get scoped email summary for an agent # noqa: E501

Returns lightweight metadata and headers for an email after resolving its inbox and checking the agent key scope. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_email_summary_with_http_info(email_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: ID of email to inspect (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(EmailPreview, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_email_thread(self, email_id, **kwargs)

Get a scoped email thread for an agent # noqa: E501

Returns thread metadata and ordered messages using an email ID as the authorization anchor. Arbitrary thread-ID probing is not allowed. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_email_thread(email_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: (required) :param str sort: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: ScopedEmailThread If the method is called asynchronously, returns the request thread.

def agent_get_email_thread_with_http_info(self, email_id, **kwargs)

Get a scoped email thread for an agent # noqa: E501

Returns thread metadata and ordered messages using an email ID as the authorization anchor. Arbitrary thread-ID probing is not allowed. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_email_thread_with_http_info(email_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: (required) :param str sort: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(ScopedEmailThread, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_email_with_http_info(self, email_id, **kwargs)

Get scoped hydrated email for an agent # noqa: E501

Returns parsed email content after resolving the message inbox and checking agent scope. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_email_with_http_info(email_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: ID of email to inspect (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(Email, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_latest_inbox_email(self, inbox_id, **kwargs)

Get latest scoped inbox email for an agent # noqa: E501

Waits for and returns the latest email in one scoped inbox. This is the agent-shaped equivalent of latest-message polling. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_latest_inbox_email(inbox_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: ID of inbox the agent may read (required) :param int timeout_millis: Timeout milliseconds to wait for latest email :param bool unread_only: Only return unread emails :param datetime since: Only return email received at or after this time :param datetime before: Only return email received before this time :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: Email If the method is called asynchronously, returns the request thread.

def agent_get_latest_inbox_email_with_http_info(self, inbox_id, **kwargs)

Get latest scoped inbox email for an agent # noqa: E501

Waits for and returns the latest email in one scoped inbox. This is the agent-shaped equivalent of latest-message polling. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_latest_inbox_email_with_http_info(inbox_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: ID of inbox the agent may read (required) :param int timeout_millis: Timeout milliseconds to wait for latest email :param bool unread_only: Only return unread emails :param datetime since: Only return email received at or after this time :param datetime before: Only return email received before this time :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(Email, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_next_work_item(self, get_next_agent_work_item_options, **kwargs)

Claim the next conversation work item # noqa: E501

Selects the oldest available scoped conversation and atomically claims it for one worker. This combines queue selection and claim acquisition so concurrent workers do not need to coordinate those steps themselves. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_next_work_item(get_next_agent_work_item_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param GetNextAgentWorkItemOptions get_next_agent_work_item_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentWorkItemDto If the method is called asynchronously, returns the request thread.

def agent_get_next_work_item_with_http_info(self, get_next_agent_work_item_options, **kwargs)

Claim the next conversation work item # noqa: E501

Selects the oldest available scoped conversation and atomically claims it for one worker. This combines queue selection and claim acquisition so concurrent workers do not need to coordinate those steps themselves. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_next_work_item_with_http_info(get_next_agent_work_item_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param GetNextAgentWorkItemOptions get_next_agent_work_item_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentWorkItemDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_phone_message_thread_items(self, phone_number_id, other_phone_number, **kwargs)

List SMS thread messages # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_phone_message_thread_items(phone_number_id, other_phone_number, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param str other_phone_number: Other participant phone number in E.164 format (required) :param int page: :param int size: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: PagePhoneMessageThreadItemProjection If the method is called asynchronously, returns the request thread.

def agent_get_phone_message_thread_items_with_http_info(self, phone_number_id, other_phone_number, **kwargs)

List SMS thread messages # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_phone_message_thread_items_with_http_info(phone_number_id, other_phone_number, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param str other_phone_number: Other participant phone number in E.164 format (required) :param int page: :param int size: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(PagePhoneMessageThreadItemProjection, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_phone_message_threads(self, phone_number_id, **kwargs)

List SMS threads # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_phone_message_threads(phone_number_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param int page: :param int size: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: PagePhoneMessageThreadProjection If the method is called asynchronously, returns the request thread.

def agent_get_phone_message_threads_with_http_info(self, phone_number_id, **kwargs)

List SMS threads # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_phone_message_threads_with_http_info(phone_number_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param int page: :param int size: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(PagePhoneMessageThreadProjection, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_phone_number(self, phone_number_id, **kwargs)

Get an assigned phone number # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_phone_number(phone_number_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: PhoneNumberDto If the method is called asynchronously, returns the request thread.

def agent_get_phone_number_with_http_info(self, phone_number_id, **kwargs)

Get an assigned phone number # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_phone_number_with_http_info(phone_number_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(PhoneNumberDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_phone_numbers(self, **kwargs)

List assigned phone numbers # noqa: E501

Returns only active phone numbers explicitly assigned to this agent connection. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param int page: :param int size: :param str sort: :param str search: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: PageAgentPhoneNumber If the method is called asynchronously, returns the request thread.

def agent_get_phone_numbers_with_http_info(self, **kwargs)

List assigned phone numbers # noqa: E501

Returns only active phone numbers explicitly assigned to this agent connection. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param int page: :param int size: :param str sort: :param str search: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(PageAgentPhoneNumber, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_received_sms_message(self, phone_number_id, sms_id, **kwargs)

Get received SMS # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_received_sms_message(phone_number_id, sms_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param str sms_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: SmsDto If the method is called asynchronously, returns the request thread.

def agent_get_received_sms_message_with_http_info(self, phone_number_id, sms_id, **kwargs)

Get received SMS # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_received_sms_message_with_http_info(phone_number_id, sms_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param str sms_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(SmsDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_received_sms_messages(self, phone_number_id, **kwargs)

List received SMS for an assigned phone number # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_received_sms_messages(phone_number_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param int page: :param int size: :param str sort: :param datetime since: :param datetime before: :param str search: :param bool favourite: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: PageSmsProjection If the method is called asynchronously, returns the request thread.

def agent_get_received_sms_messages_with_http_info(self, phone_number_id, **kwargs)

List received SMS for an assigned phone number # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_received_sms_messages_with_http_info(phone_number_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param int page: :param int size: :param str sort: :param datetime since: :param datetime before: :param str search: :param bool favourite: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(PageSmsProjection, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_sent_sms_message(self, phone_number_id, sent_sms_id, **kwargs)

Get sent SMS # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_sent_sms_message(phone_number_id, sent_sms_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param str sent_sms_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: SentSmsDto If the method is called asynchronously, returns the request thread.

def agent_get_sent_sms_message_with_http_info(self, phone_number_id, sent_sms_id, **kwargs)

Get sent SMS # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_sent_sms_message_with_http_info(phone_number_id, sent_sms_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param str sent_sms_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(SentSmsDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_sent_sms_messages(self, phone_number_id, **kwargs)

List sent SMS for an assigned phone number # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_sent_sms_messages(phone_number_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param int page: :param int size: :param str sort: :param datetime since: :param datetime before: :param str search: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: PageSentSmsProjection If the method is called asynchronously, returns the request thread.

def agent_get_sent_sms_messages_with_http_info(self, phone_number_id, **kwargs)

List sent SMS for an assigned phone number # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_sent_sms_messages_with_http_info(phone_number_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param int page: :param int size: :param str sort: :param datetime since: :param datetime before: :param str search: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(PageSentSmsProjection, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_sms_conversation(self, conversation_id, **kwargs)

Get one SMS conversation # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_sms_conversation(conversation_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentSmsConversationDetailDto If the method is called asynchronously, returns the request thread.

def agent_get_sms_conversation_with_http_info(self, conversation_id, **kwargs)

Get one SMS conversation # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_sms_conversation_with_http_info(conversation_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentSmsConversationDetailDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_totp_device(self, id, **kwargs)

Get an agent-accessible TOTP device # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_totp_device(id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: TotpDeviceDto If the method is called asynchronously, returns the request thread.

def agent_get_totp_device_by(self, **kwargs)

Find an agent-accessible TOTP device by name, issuer, or username # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param str name: :param str issuer: :param str username: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: TotpDeviceOptionalDto If the method is called asynchronously, returns the request thread.

def agent_get_totp_device_by_with_http_info(self, **kwargs)

Find an agent-accessible TOTP device by name, issuer, or username # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param str name: :param str issuer: :param str username: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(TotpDeviceOptionalDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_totp_device_with_http_info(self, id, **kwargs)

Get an agent-accessible TOTP device # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_get_totp_device_with_http_info(id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(TotpDeviceDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_get_totp_devices(self, **kwargs)

List agent-accessible TOTP devices # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param int page: :param int size: :param str sort: :param str issuer: :param str username: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: PageTotpDeviceProjection If the method is called asynchronously, returns the request thread.

def agent_get_totp_devices_with_http_info(self, **kwargs)

List agent-accessible TOTP devices # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param int page: :param int size: :param str sort: :param str issuer: :param str username: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(PageTotpDeviceProjection, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_list_accessible_inboxes(self, **kwargs)

List inboxes accessible to an agent # noqa: E501

Returns the inbox IDs, addresses, names, and tags visible to this resource-scoped agent key. Agents should use this endpoint instead of guessing inbox IDs. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param int size: :param str sort: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AccessibleInboxList If the method is called asynchronously, returns the request thread.

def agent_list_accessible_inboxes_with_http_info(self, **kwargs)

List inboxes accessible to an agent # noqa: E501

Returns the inbox IDs, addresses, names, and tags visible to this resource-scoped agent key. Agents should use this endpoint instead of guessing inbox IDs. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param int size: :param str sort: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AccessibleInboxList, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_list_automation_events(self, **kwargs)

Read durable scoped automation events # noqa: E501

Returns an ordered at-least-once event batch. Persist nextCursor after processing and deduplicate by eventId. waitSeconds enables bounded long polling; production workers should not continuously call latest-email polling. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param str cursor: :param list[str] event_type: :param int size: :param int wait_seconds: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentAutomationEventPageDto If the method is called asynchronously, returns the request thread.

def agent_list_automation_events_with_http_info(self, **kwargs)

Read durable scoped automation events # noqa: E501

Returns an ordered at-least-once event batch. Persist nextCursor after processing and deduplicate by eventId. waitSeconds enables bounded long polling; production workers should not continuously call latest-email polling. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param str cursor: :param list[str] event_type: :param int size: :param int wait_seconds: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentAutomationEventPageDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_list_conversations_v2(self, **kwargs)

List active conversations with an opaque keyset cursor # noqa: E501

Reads the bounded mail-thread projection and applies current connection scope on every request. Persist nextCursor only after processing the returned page. Exact totals are intentionally omitted. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param str workflow_state: :param str outcome: :param str review_status: :param str inbox_id: :param bool unread: :param bool has_attachments: :param datetime since: :param datetime before: :param str search: :param str sort: :param str cursor: :param int size: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentConversationCursorPageDto If the method is called asynchronously, returns the request thread.

def agent_list_conversations_v2_with_http_info(self, **kwargs)

List active conversations with an opaque keyset cursor # noqa: E501

Reads the bounded mail-thread projection and applies current connection scope on every request. Persist nextCursor only after processing the returned page. Exact totals are intentionally omitted. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param str workflow_state: :param str outcome: :param str review_status: :param str inbox_id: :param bool unread: :param bool has_attachments: :param datetime since: :param datetime before: :param str search: :param str sort: :param str cursor: :param int size: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentConversationCursorPageDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_list_email_attachments(self, email_id, **kwargs)

List attachments on a scoped email for an agent # noqa: E501

Returns bounded attachment metadata only after verifying the email belongs to an inbox visible to the agent key. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_list_email_attachments(email_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: list[AttachmentMetaData] If the method is called asynchronously, returns the request thread.

def agent_list_email_attachments_with_http_info(self, email_id, **kwargs)

List attachments on a scoped email for an agent # noqa: E501

Returns bounded attachment metadata only after verifying the email belongs to an inbox visible to the agent key. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_list_email_attachments_with_http_info(email_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(list[AttachmentMetaData], status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_list_email_drafts(self, inbox_id, **kwargs)

List scoped email drafts for an agent # noqa: E501

Lists draft previews for one scoped inbox. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_list_email_drafts(inbox_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: ID of inbox to list drafts for (required) :param int page: Optional page index in draft pagination :param int size: Optional page size in draft pagination :param str sort: Optional createdAt sort direction ASC or DESC :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: PageEmailDraftProjection If the method is called asynchronously, returns the request thread.

def agent_list_email_drafts_with_http_info(self, inbox_id, **kwargs)

List scoped email drafts for an agent # noqa: E501

Lists draft previews for one scoped inbox. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_list_email_drafts_with_http_info(inbox_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: ID of inbox to list drafts for (required) :param int page: Optional page index in draft pagination :param int size: Optional page size in draft pagination :param str sort: Optional createdAt sort direction ASC or DESC :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(PageEmailDraftProjection, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_list_inbox_emails(self, inbox_id, **kwargs)

List scoped inbox emails for an agent # noqa: E501

Returns paginated email previews for one inbox after checking the agent key has AGENT_READ_EMAIL and is scoped to the inbox. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_list_inbox_emails(inbox_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: ID of inbox the agent may read (required) :param int page: Optional page index in inbox emails list pagination :param int size: Optional page size in inbox emails list pagination :param str sort: Optional createdAt sort direction ASC or DESC :param datetime since: Optional filter by received after given date time :param datetime before: Optional filter by received before given date time :param bool sync_connectors: Sync connectors before fetching emails :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: PageEmailPreview If the method is called asynchronously, returns the request thread.

def agent_list_inbox_emails_with_http_info(self, inbox_id, **kwargs)

List scoped inbox emails for an agent # noqa: E501

Returns paginated email previews for one inbox after checking the agent key has AGENT_READ_EMAIL and is scoped to the inbox. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_list_inbox_emails_with_http_info(inbox_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: ID of inbox the agent may read (required) :param int page: Optional page index in inbox emails list pagination :param int size: Optional page size in inbox emails list pagination :param str sort: Optional createdAt sort direction ASC or DESC :param datetime since: Optional filter by received after given date time :param datetime before: Optional filter by received before given date time :param bool sync_connectors: Sync connectors before fetching emails :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(PageEmailPreview, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_list_inbox_threads(self, inbox_id, **kwargs)

List scoped inbox threads for an agent # noqa: E501

Lists conversation threads for one scoped inbox, including unread state, attachment presence, message count, and latest-message excerpts. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_list_inbox_threads(inbox_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: (required) :param int page: :param int size: :param str sort: :param str search: :param datetime since: :param datetime before: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: PageEmailThreadProjection If the method is called asynchronously, returns the request thread.

def agent_list_inbox_threads_with_http_info(self, inbox_id, **kwargs)

List scoped inbox threads for an agent # noqa: E501

Lists conversation threads for one scoped inbox, including unread state, attachment presence, message count, and latest-message excerpts. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_list_inbox_threads_with_http_info(inbox_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: (required) :param int page: :param int size: :param str sort: :param str search: :param datetime since: :param datetime before: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(PageEmailThreadProjection, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_list_sms_conversations(self, **kwargs)

List active SMS conversations # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param str workflow_state: :param str outcome: :param str review_status: :param str phone_number_id: :param bool unread: :param bool has_media: :param datetime since: :param datetime before: :param str search: :param str sort: :param str cursor: :param int size: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentSmsConversationCursorPageDto If the method is called asynchronously, returns the request thread.

def agent_list_sms_conversations_with_http_info(self, **kwargs)

List active SMS conversations # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param str workflow_state: :param str outcome: :param str review_status: :param str phone_number_id: :param bool unread: :param bool has_media: :param datetime since: :param datetime before: :param str search: :param str sort: :param str cursor: :param int size: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentSmsConversationCursorPageDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_prepare_work_item_reply(self, conversation_id, prepare_agent_reply_options, **kwargs)

Prepare a guarded reply draft # noqa: E501

Checks that the selected conversation and latest inbound email are still current, then creates a correctly threaded reply draft. An optional internal note records context for human review without sending email. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_prepare_work_item_reply(conversation_id, prepare_agent_reply_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param PrepareAgentReplyOptions prepare_agent_reply_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentPreparedReplyDto If the method is called asynchronously, returns the request thread.

def agent_prepare_work_item_reply_with_http_info(self, conversation_id, prepare_agent_reply_options, **kwargs)

Prepare a guarded reply draft # noqa: E501

Checks that the selected conversation and latest inbound email are still current, then creates a correctly threaded reply draft. An optional internal note records context for human review without sending email. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_prepare_work_item_reply_with_http_info(conversation_id, prepare_agent_reply_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param PrepareAgentReplyOptions prepare_agent_reply_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentPreparedReplyDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_release_conversation_claim(self, conversation_id, claim_id, **kwargs)

Release a conversation claim # noqa: E501

Release is idempotent; repeating it does not fail. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_release_conversation_claim(conversation_id, claim_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param str claim_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: None If the method is called asynchronously, returns the request thread.

def agent_release_conversation_claim_with_http_info(self, conversation_id, claim_id, **kwargs)

Release a conversation claim # noqa: E501

Release is idempotent; repeating it does not fail. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_release_conversation_claim_with_http_info(conversation_id, claim_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param str claim_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: None If the method is called asynchronously, returns the request thread.

def agent_release_sms_claim(self, conversation_id, claim_id, **kwargs)

Release an SMS conversation claim # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_release_sms_claim(conversation_id, claim_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param str claim_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: None If the method is called asynchronously, returns the request thread.

def agent_release_sms_claim_with_http_info(self, conversation_id, claim_id, **kwargs)

Release an SMS conversation claim # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_release_sms_claim_with_http_info(conversation_id, claim_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param str claim_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: None If the method is called asynchronously, returns the request thread.

def agent_renew_conversation_claim(self, conversation_id, claim_id, renew_agent_conversation_claim_options, **kwargs)

Renew a conversation claim # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_renew_conversation_claim(conversation_id, claim_id, renew_agent_conversation_claim_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param str claim_id: (required) :param RenewAgentConversationClaimOptions renew_agent_conversation_claim_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentConversationClaimDto If the method is called asynchronously, returns the request thread.

def agent_renew_conversation_claim_with_http_info(self, conversation_id, claim_id, renew_agent_conversation_claim_options, **kwargs)

Renew a conversation claim # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_renew_conversation_claim_with_http_info(conversation_id, claim_id, renew_agent_conversation_claim_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param str claim_id: (required) :param RenewAgentConversationClaimOptions renew_agent_conversation_claim_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentConversationClaimDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_renew_sms_claim(self, conversation_id, claim_id, renew_agent_conversation_claim_options, **kwargs)

Renew an SMS conversation claim # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_renew_sms_claim(conversation_id, claim_id, renew_agent_conversation_claim_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param str claim_id: (required) :param RenewAgentConversationClaimOptions renew_agent_conversation_claim_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentConversationClaimDto If the method is called asynchronously, returns the request thread.

def agent_renew_sms_claim_with_http_info(self, conversation_id, claim_id, renew_agent_conversation_claim_options, **kwargs)

Renew an SMS conversation claim # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_renew_sms_claim_with_http_info(conversation_id, claim_id, renew_agent_conversation_claim_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param str claim_id: (required) :param RenewAgentConversationClaimOptions renew_agent_conversation_claim_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentConversationClaimDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_reply_to_email(self, email_id, reply_to_email_options, **kwargs)

Reply to a scoped email as an agent # noqa: E501

Sends a reply using the original conversation context after checking AGENT_REPLY_EMAIL and inbox scope. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_reply_to_email(email_id, reply_to_email_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: ID of email to reply to (required) :param ReplyToEmailOptions reply_to_email_options: (required) :param str idempotency_key: :param int expected_conversation_version: :param str expected_latest_email_id: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: SentEmailDto If the method is called asynchronously, returns the request thread.

def agent_reply_to_email_with_http_info(self, email_id, reply_to_email_options, **kwargs)

Reply to a scoped email as an agent # noqa: E501

Sends a reply using the original conversation context after checking AGENT_REPLY_EMAIL and inbox scope. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_reply_to_email_with_http_info(email_id, reply_to_email_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: ID of email to reply to (required) :param ReplyToEmailOptions reply_to_email_options: (required) :param str idempotency_key: :param int expected_conversation_version: :param str expected_latest_email_id: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(SentEmailDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_reply_to_sms(self, phone_number_id, sms_id, sms_reply_options, **kwargs)

Reply to received SMS # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_reply_to_sms(phone_number_id, sms_id, sms_reply_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param str sms_id: (required) :param SmsReplyOptions sms_reply_options: (required) :param str idempotency_key: :param int expected_conversation_version: :param str expected_latest_message_id: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: SentSmsDto If the method is called asynchronously, returns the request thread.

def agent_reply_to_sms_with_http_info(self, phone_number_id, sms_id, sms_reply_options, **kwargs)

Reply to received SMS # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_reply_to_sms_with_http_info(phone_number_id, sms_id, sms_reply_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param str sms_id: (required) :param SmsReplyOptions sms_reply_options: (required) :param str idempotency_key: :param int expected_conversation_version: :param str expected_latest_message_id: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(SentSmsDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_report_worker_heartbeat(self, agent_worker_heartbeat_options, **kwargs)

Report a worker heartbeat # noqa: E501

Records one running worker instance and its deployed release for owner-side health monitoring. Send this during startup and periodically while the process can accept work; it does not claim or mutate a conversation. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_report_worker_heartbeat(agent_worker_heartbeat_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param AgentWorkerHeartbeatOptions agent_worker_heartbeat_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentWorkerHeartbeatDto If the method is called asynchronously, returns the request thread.

def agent_report_worker_heartbeat_with_http_info(self, agent_worker_heartbeat_options, **kwargs)

Report a worker heartbeat # noqa: E501

Records one running worker instance and its deployed release for owner-side health monitoring. Send this during startup and periodically while the process can accept work; it does not claim or mutate a conversation. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_report_worker_heartbeat_with_http_info(agent_worker_heartbeat_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param AgentWorkerHeartbeatOptions agent_worker_heartbeat_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentWorkerHeartbeatDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_request_conversation_handoff(self, conversation_id, create_agent_conversation_handoff_options, **kwargs)

Request human review for a conversation # noqa: E501

Creates or returns the active handoff and moves the shared workflow state into REVIEW without classifying the request as an operational failure. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_request_conversation_handoff(conversation_id, create_agent_conversation_handoff_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param CreateAgentConversationHandoffOptions create_agent_conversation_handoff_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentConversationHandoffDto If the method is called asynchronously, returns the request thread.

def agent_request_conversation_handoff_with_http_info(self, conversation_id, create_agent_conversation_handoff_options, **kwargs)

Request human review for a conversation # noqa: E501

Creates or returns the active handoff and moves the shared workflow state into REVIEW without classifying the request as an operational failure. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_request_conversation_handoff_with_http_info(conversation_id, create_agent_conversation_handoff_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param CreateAgentConversationHandoffOptions create_agent_conversation_handoff_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentConversationHandoffDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_request_sms_handoff(self, conversation_id, create_agent_sms_conversation_handoff_options, **kwargs)

Request human review for an SMS conversation # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_request_sms_handoff(conversation_id, create_agent_sms_conversation_handoff_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param CreateAgentSmsConversationHandoffOptions create_agent_sms_conversation_handoff_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: AgentConversationHandoffDto If the method is called asynchronously, returns the request thread.

def agent_request_sms_handoff_with_http_info(self, conversation_id, create_agent_sms_conversation_handoff_options, **kwargs)

Request human review for an SMS conversation # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_request_sms_handoff_with_http_info(conversation_id, create_agent_sms_conversation_handoff_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str conversation_id: (required) :param CreateAgentSmsConversationHandoffOptions create_agent_sms_conversation_handoff_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(AgentConversationHandoffDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_search_inbox_emails(self, inbox_id, match_options, **kwargs)

Search scoped inbox emails for an agent # noqa: E501

Searches one scoped inbox using explicit field matches and attachment conditions. Use this for deterministic automation recovery instead of repeatedly fetching the latest message. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_search_inbox_emails(inbox_id, match_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: (required) :param MatchOptions match_options: (required) :param int size: :param str sort: :param datetime since: :param datetime before: :param bool unread_only: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: list[EmailPreview] If the method is called asynchronously, returns the request thread.

def agent_search_inbox_emails_with_http_info(self, inbox_id, match_options, **kwargs)

Search scoped inbox emails for an agent # noqa: E501

Searches one scoped inbox using explicit field matches and attachment conditions. Use this for deterministic automation recovery instead of repeatedly fetching the latest message. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_search_inbox_emails_with_http_info(inbox_id, match_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: (required) :param MatchOptions match_options: (required) :param int size: :param str sort: :param datetime since: :param datetime before: :param bool unread_only: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(list[EmailPreview], status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_send_email_draft(self, inbox_id, draft_id, **kwargs)

Send a scoped email draft for an agent # noqa: E501

Sends a saved draft through the existing inbox send pipeline and deletes it only after send success. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_send_email_draft(inbox_id, draft_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: ID of inbox the draft belongs to (required) :param str draft_id: ID of draft (required) :param str idempotency_key: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: SentEmailDto If the method is called asynchronously, returns the request thread.

def agent_send_email_draft_with_http_info(self, inbox_id, draft_id, **kwargs)

Send a scoped email draft for an agent # noqa: E501

Sends a saved draft through the existing inbox send pipeline and deletes it only after send success. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_send_email_draft_with_http_info(inbox_id, draft_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: ID of inbox the draft belongs to (required) :param str draft_id: ID of draft (required) :param str idempotency_key: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(SentEmailDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_send_sms(self, phone_number_id, sms_send_options, **kwargs)

Send SMS from an assigned phone number # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_send_sms(phone_number_id, sms_send_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param SmsSendOptions sms_send_options: (required) :param str idempotency_key: :param int expected_conversation_version: :param str expected_latest_message_id: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: SentSmsDto If the method is called asynchronously, returns the request thread.

def agent_send_sms_with_http_info(self, phone_number_id, sms_send_options, **kwargs)

Send SMS from an assigned phone number # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_send_sms_with_http_info(phone_number_id, sms_send_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str phone_number_id: (required) :param SmsSendOptions sms_send_options: (required) :param str idempotency_key: :param int expected_conversation_version: :param str expected_latest_message_id: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(SentSmsDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_update_email_draft(self, inbox_id, draft_id, send_email_options, **kwargs)

Update a scoped email draft for an agent # noqa: E501

Replaces the SendEmailOptions stored for a draft. The draft remains attached to its original inbox. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_update_email_draft(inbox_id, draft_id, send_email_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: ID of inbox the draft belongs to (required) :param str draft_id: ID of draft (required) :param SendEmailOptions send_email_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: EmailDraftDto If the method is called asynchronously, returns the request thread.

def agent_update_email_draft_with_http_info(self, inbox_id, draft_id, send_email_options, **kwargs)

Update a scoped email draft for an agent # noqa: E501

Replaces the SendEmailOptions stored for a draft. The draft remains attached to its original inbox. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_update_email_draft_with_http_info(inbox_id, draft_id, send_email_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: ID of inbox the draft belongs to (required) :param str draft_id: ID of draft (required) :param SendEmailOptions send_email_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(EmailDraftDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_update_inbox(self, inbox_id, update_inbox_options, **kwargs)

Update an inbox visible to an inbox-manager connection # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_update_inbox(inbox_id, update_inbox_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: (required) :param UpdateInboxOptions update_inbox_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: InboxDto If the method is called asynchronously, returns the request thread.

def agent_update_inbox_with_http_info(self, inbox_id, update_inbox_options, **kwargs)

Update an inbox visible to an inbox-manager connection # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_update_inbox_with_http_info(inbox_id, update_inbox_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str inbox_id: (required) :param UpdateInboxOptions update_inbox_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(InboxDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def agent_update_totp_device(self, id, update_totp_device_options, **kwargs)

Update an agent-managed TOTP device # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_update_totp_device(id, update_totp_device_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str id: (required) :param UpdateTotpDeviceOptions update_totp_device_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: TotpDeviceDto If the method is called asynchronously, returns the request thread.

def agent_update_totp_device_with_http_info(self, id, update_totp_device_options, **kwargs)

Update an agent-managed TOTP device # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.agent_update_totp_device_with_http_info(id, update_totp_device_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str id: (required) :param UpdateTotpDeviceOptions update_totp_device_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(TotpDeviceDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.