# coding: utf-8

"""
    Ephor.ai

    Collaborative AI

    The version of the OpenAPI document: 1.3.0
    Generated by OpenAPI Generator (https://openapi-generator.tech)

    Do not edit the class manually.
"""  # noqa: E501

import warnings
from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
from typing import Any, Dict, List, Optional, Tuple, Union
from typing_extensions import Annotated

from pydantic import StrictStr
from typing import Any, List
from ephor_server_ti_client.models.bot_dispatch_request import BotDispatchRequest
from ephor_server_ti_client.models.bot_stop_request import BotStopRequest
from ephor_server_ti_client.models.live_kit_connection_response import LiveKitConnectionResponse
from ephor_server_ti_client.models.second_brain_input import SecondBrainInput
from ephor_server_ti_client.models.second_brain_link_request import SecondBrainLinkRequest
from ephor_server_ti_client.models.second_brain_output import SecondBrainOutput
from ephor_server_ti_client.models.transcript import Transcript
from ephor_server_ti_client.models.transcript_message import TranscriptMessage

from ephor_server_ti_client.api_client import ApiClient, RequestSerialized
from ephor_server_ti_client.api_response import ApiResponse
from ephor_server_ti_client.rest import RESTResponseType


class SecondBrainApi:
    """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) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def bot_dispatch_api_v1_second_brain_bot_dispatch_post(
        self,
        bot_dispatch_request: BotDispatchRequest,
    ) -> object:
        """Bot Dispatch


        :param bot_dispatch_request: (required)
        :type bot_dispatch_request: BotDispatchRequest
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._bot_dispatch_api_v1_second_brain_bot_dispatch_post_serialize(
            bot_dispatch_request=bot_dispatch_request,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "object",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def bot_dispatch_api_v1_second_brain_bot_dispatch_post_with_http_info(
        self,
        bot_dispatch_request: BotDispatchRequest,
    ) -> ApiResponse[object]:
        """Bot Dispatch


        :param bot_dispatch_request: (required)
        :type bot_dispatch_request: BotDispatchRequest
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._bot_dispatch_api_v1_second_brain_bot_dispatch_post_serialize(
            bot_dispatch_request=bot_dispatch_request,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "object",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def bot_dispatch_api_v1_second_brain_bot_dispatch_post_without_preload_content(
        self,
        bot_dispatch_request: BotDispatchRequest,
    ) -> RESTResponseType:
        """Bot Dispatch


        :param bot_dispatch_request: (required)
        :type bot_dispatch_request: BotDispatchRequest
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._bot_dispatch_api_v1_second_brain_bot_dispatch_post_serialize(
            bot_dispatch_request=bot_dispatch_request,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "object",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        return response_data.response


    def _bot_dispatch_api_v1_second_brain_bot_dispatch_post_serialize(
        self,
        bot_dispatch_request,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if bot_dispatch_request is not None:
            _body_params = bot_dispatch_request


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'APIKeyHeader'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/v1/second-brain/bot-dispatch',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def bot_status_api_v1_second_brain_bot_status_get(
        self,
        task_id: StrictStr,
    ) -> object:
        """Bot Status


        :param task_id: (required)
        :type task_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._bot_status_api_v1_second_brain_bot_status_get_serialize(
            task_id=task_id,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "object",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def bot_status_api_v1_second_brain_bot_status_get_with_http_info(
        self,
        task_id: StrictStr,
    ) -> ApiResponse[object]:
        """Bot Status


        :param task_id: (required)
        :type task_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._bot_status_api_v1_second_brain_bot_status_get_serialize(
            task_id=task_id,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "object",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def bot_status_api_v1_second_brain_bot_status_get_without_preload_content(
        self,
        task_id: StrictStr,
    ) -> RESTResponseType:
        """Bot Status


        :param task_id: (required)
        :type task_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._bot_status_api_v1_second_brain_bot_status_get_serialize(
            task_id=task_id,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "object",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        return response_data.response


    def _bot_status_api_v1_second_brain_bot_status_get_serialize(
        self,
        task_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if task_id is not None:
            
            _query_params.append(('task_id', task_id))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'APIKeyHeader'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/v1/second-brain/bot-status',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def bot_stop_api_v1_second_brain_bot_stop_post(
        self,
        bot_stop_request: BotStopRequest,
    ) -> object:
        """Bot Stop


        :param bot_stop_request: (required)
        :type bot_stop_request: BotStopRequest
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._bot_stop_api_v1_second_brain_bot_stop_post_serialize(
            bot_stop_request=bot_stop_request,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "object",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def bot_stop_api_v1_second_brain_bot_stop_post_with_http_info(
        self,
        bot_stop_request: BotStopRequest,
    ) -> ApiResponse[object]:
        """Bot Stop


        :param bot_stop_request: (required)
        :type bot_stop_request: BotStopRequest
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._bot_stop_api_v1_second_brain_bot_stop_post_serialize(
            bot_stop_request=bot_stop_request,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "object",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def bot_stop_api_v1_second_brain_bot_stop_post_without_preload_content(
        self,
        bot_stop_request: BotStopRequest,
    ) -> RESTResponseType:
        """Bot Stop


        :param bot_stop_request: (required)
        :type bot_stop_request: BotStopRequest
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._bot_stop_api_v1_second_brain_bot_stop_post_serialize(
            bot_stop_request=bot_stop_request,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "object",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        return response_data.response


    def _bot_stop_api_v1_second_brain_bot_stop_post_serialize(
        self,
        bot_stop_request,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if bot_stop_request is not None:
            _body_params = bot_stop_request


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'APIKeyHeader'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/v1/second-brain/bot-stop',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def delete_active_transcript_api_v1_second_brain_active_transcript_delete(
        self,
    ) -> None:
        """Delete Active Transcript


        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_active_transcript_api_v1_second_brain_active_transcript_delete_serialize(
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def delete_active_transcript_api_v1_second_brain_active_transcript_delete_with_http_info(
        self,
    ) -> ApiResponse[None]:
        """Delete Active Transcript


        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_active_transcript_api_v1_second_brain_active_transcript_delete_serialize(
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def delete_active_transcript_api_v1_second_brain_active_transcript_delete_without_preload_content(
        self,
    ) -> RESTResponseType:
        """Delete Active Transcript


        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_active_transcript_api_v1_second_brain_active_transcript_delete_serialize(
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        return response_data.response


    def _delete_active_transcript_api_v1_second_brain_active_transcript_delete_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter




        # authentication setting
        _auth_settings: List[str] = [
            'APIKeyHeader'
        ]

        return self.api_client.param_serialize(
            method='DELETE',
            resource_path='/api/v1/second-brain/active-transcript',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def delete_spovs_api_v1_second_brain_project_id_id_spovs_delete(
        self,
        project_id: StrictStr,
        id: StrictStr,
    ) -> None:
        """Delete Spovs


        :param project_id: (required)
        :type project_id: str
        :param id: (required)
        :type id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_spovs_api_v1_second_brain_project_id_id_spovs_delete_serialize(
            project_id=project_id,
            id=id,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def delete_spovs_api_v1_second_brain_project_id_id_spovs_delete_with_http_info(
        self,
        project_id: StrictStr,
        id: StrictStr,
    ) -> ApiResponse[None]:
        """Delete Spovs


        :param project_id: (required)
        :type project_id: str
        :param id: (required)
        :type id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_spovs_api_v1_second_brain_project_id_id_spovs_delete_serialize(
            project_id=project_id,
            id=id,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def delete_spovs_api_v1_second_brain_project_id_id_spovs_delete_without_preload_content(
        self,
        project_id: StrictStr,
        id: StrictStr,
    ) -> RESTResponseType:
        """Delete Spovs


        :param project_id: (required)
        :type project_id: str
        :param id: (required)
        :type id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_spovs_api_v1_second_brain_project_id_id_spovs_delete_serialize(
            project_id=project_id,
            id=id,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        return response_data.response


    def _delete_spovs_api_v1_second_brain_project_id_id_spovs_delete_serialize(
        self,
        project_id,
        id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['project_id'] = project_id
        if id is not None:
            _path_params['id'] = id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'APIKeyHeader'
        ]

        return self.api_client.param_serialize(
            method='DELETE',
            resource_path='/api/v1/second-brain/{project_id}/{id}/spovs',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def extract_spovs_api_v1_second_brain_extract_spovs_post(
        self,
        second_brain_link_request: SecondBrainLinkRequest,
    ) -> SecondBrainOutput:
        """Extract Spovs


        :param second_brain_link_request: (required)
        :type second_brain_link_request: SecondBrainLinkRequest
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._extract_spovs_api_v1_second_brain_extract_spovs_post_serialize(
            second_brain_link_request=second_brain_link_request,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SecondBrainOutput",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def extract_spovs_api_v1_second_brain_extract_spovs_post_with_http_info(
        self,
        second_brain_link_request: SecondBrainLinkRequest,
    ) -> ApiResponse[SecondBrainOutput]:
        """Extract Spovs


        :param second_brain_link_request: (required)
        :type second_brain_link_request: SecondBrainLinkRequest
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._extract_spovs_api_v1_second_brain_extract_spovs_post_serialize(
            second_brain_link_request=second_brain_link_request,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SecondBrainOutput",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def extract_spovs_api_v1_second_brain_extract_spovs_post_without_preload_content(
        self,
        second_brain_link_request: SecondBrainLinkRequest,
    ) -> RESTResponseType:
        """Extract Spovs


        :param second_brain_link_request: (required)
        :type second_brain_link_request: SecondBrainLinkRequest
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._extract_spovs_api_v1_second_brain_extract_spovs_post_serialize(
            second_brain_link_request=second_brain_link_request,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SecondBrainOutput",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        return response_data.response


    def _extract_spovs_api_v1_second_brain_extract_spovs_post_serialize(
        self,
        second_brain_link_request,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if second_brain_link_request is not None:
            _body_params = second_brain_link_request


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'APIKeyHeader'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/v1/second-brain/extract-spovs',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_active_transcript_api_v1_second_brain_active_transcript_get(
        self,
    ) -> Transcript:
        """Get Active Transcript


        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_active_transcript_api_v1_second_brain_active_transcript_get_serialize(
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Transcript",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_active_transcript_api_v1_second_brain_active_transcript_get_with_http_info(
        self,
    ) -> ApiResponse[Transcript]:
        """Get Active Transcript


        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_active_transcript_api_v1_second_brain_active_transcript_get_serialize(
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Transcript",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_active_transcript_api_v1_second_brain_active_transcript_get_without_preload_content(
        self,
    ) -> RESTResponseType:
        """Get Active Transcript


        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_active_transcript_api_v1_second_brain_active_transcript_get_serialize(
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Transcript",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        return response_data.response


    def _get_active_transcript_api_v1_second_brain_active_transcript_get_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'APIKeyHeader'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/v1/second-brain/active-transcript',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_latest_spov_api_v1_second_brain_project_id_spovs_get(
        self,
        project_id: StrictStr,
    ) -> SecondBrainOutput:
        """Get Latest Spov


        :param project_id: (required)
        :type project_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_latest_spov_api_v1_second_brain_project_id_spovs_get_serialize(
            project_id=project_id,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SecondBrainOutput",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_latest_spov_api_v1_second_brain_project_id_spovs_get_with_http_info(
        self,
        project_id: StrictStr,
    ) -> ApiResponse[SecondBrainOutput]:
        """Get Latest Spov


        :param project_id: (required)
        :type project_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_latest_spov_api_v1_second_brain_project_id_spovs_get_serialize(
            project_id=project_id,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SecondBrainOutput",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_latest_spov_api_v1_second_brain_project_id_spovs_get_without_preload_content(
        self,
        project_id: StrictStr,
    ) -> RESTResponseType:
        """Get Latest Spov


        :param project_id: (required)
        :type project_id: str
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_latest_spov_api_v1_second_brain_project_id_spovs_get_serialize(
            project_id=project_id,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SecondBrainOutput",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        return response_data.response


    def _get_latest_spov_api_v1_second_brain_project_id_spovs_get_serialize(
        self,
        project_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['project_id'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'APIKeyHeader'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/v1/second-brain/{project_id}/spovs',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_livekit_connection_api_v1_second_brain_livekit_connection_get(
        self,
    ) -> LiveKitConnectionResponse:
        """Get Livekit Connection

        Generate LiveKit connection details for voice assistant

        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_livekit_connection_api_v1_second_brain_livekit_connection_get_serialize(
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "LiveKitConnectionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_livekit_connection_api_v1_second_brain_livekit_connection_get_with_http_info(
        self,
    ) -> ApiResponse[LiveKitConnectionResponse]:
        """Get Livekit Connection

        Generate LiveKit connection details for voice assistant

        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_livekit_connection_api_v1_second_brain_livekit_connection_get_serialize(
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "LiveKitConnectionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_livekit_connection_api_v1_second_brain_livekit_connection_get_without_preload_content(
        self,
    ) -> RESTResponseType:
        """Get Livekit Connection

        Generate LiveKit connection details for voice assistant

        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_livekit_connection_api_v1_second_brain_livekit_connection_get_serialize(
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "LiveKitConnectionResponse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        return response_data.response


    def _get_livekit_connection_api_v1_second_brain_livekit_connection_get_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'APIKeyHeader'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/v1/second-brain/livekit-connection',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_transcripts_api_v1_second_brain_transcripts_get(
        self,
    ) -> List[Transcript]:
        """Get Transcripts


        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_transcripts_api_v1_second_brain_transcripts_get_serialize(
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[Transcript]",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_transcripts_api_v1_second_brain_transcripts_get_with_http_info(
        self,
    ) -> ApiResponse[List[Transcript]]:
        """Get Transcripts


        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_transcripts_api_v1_second_brain_transcripts_get_serialize(
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[Transcript]",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_transcripts_api_v1_second_brain_transcripts_get_without_preload_content(
        self,
    ) -> RESTResponseType:
        """Get Transcripts


        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_transcripts_api_v1_second_brain_transcripts_get_serialize(
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[Transcript]",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        return response_data.response


    def _get_transcripts_api_v1_second_brain_transcripts_get_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'APIKeyHeader'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/v1/second-brain/transcripts',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def save_message_api_v1_second_brain_save_transcript_message_post(
        self,
        transcript_message: TranscriptMessage,
    ) -> object:
        """Save Message


        :param transcript_message: (required)
        :type transcript_message: TranscriptMessage
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._save_message_api_v1_second_brain_save_transcript_message_post_serialize(
            transcript_message=transcript_message,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "object",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def save_message_api_v1_second_brain_save_transcript_message_post_with_http_info(
        self,
        transcript_message: TranscriptMessage,
    ) -> ApiResponse[object]:
        """Save Message


        :param transcript_message: (required)
        :type transcript_message: TranscriptMessage
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._save_message_api_v1_second_brain_save_transcript_message_post_serialize(
            transcript_message=transcript_message,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "object",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def save_message_api_v1_second_brain_save_transcript_message_post_without_preload_content(
        self,
        transcript_message: TranscriptMessage,
    ) -> RESTResponseType:
        """Save Message


        :param transcript_message: (required)
        :type transcript_message: TranscriptMessage
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._save_message_api_v1_second_brain_save_transcript_message_post_serialize(
            transcript_message=transcript_message,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "object",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        return response_data.response


    def _save_message_api_v1_second_brain_save_transcript_message_post_serialize(
        self,
        transcript_message,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if transcript_message is not None:
            _body_params = transcript_message


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'APIKeyHeader'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/v1/second-brain/save-transcript-message',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def save_spovs_api_v1_second_brain_spovs_post(
        self,
        second_brain_input: SecondBrainInput,
    ) -> SecondBrainOutput:
        """Save Spovs


        :param second_brain_input: (required)
        :type second_brain_input: SecondBrainInput
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._save_spovs_api_v1_second_brain_spovs_post_serialize(
            second_brain_input=second_brain_input,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SecondBrainOutput",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def save_spovs_api_v1_second_brain_spovs_post_with_http_info(
        self,
        second_brain_input: SecondBrainInput,
    ) -> ApiResponse[SecondBrainOutput]:
        """Save Spovs


        :param second_brain_input: (required)
        :type second_brain_input: SecondBrainInput
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._save_spovs_api_v1_second_brain_spovs_post_serialize(
            second_brain_input=second_brain_input,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SecondBrainOutput",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def save_spovs_api_v1_second_brain_spovs_post_without_preload_content(
        self,
        second_brain_input: SecondBrainInput,
    ) -> RESTResponseType:
        """Save Spovs


        :param second_brain_input: (required)
        :type second_brain_input: SecondBrainInput
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._save_spovs_api_v1_second_brain_spovs_post_serialize(
            second_brain_input=second_brain_input,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SecondBrainOutput",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        return response_data.response


    def _save_spovs_api_v1_second_brain_spovs_post_serialize(
        self,
        second_brain_input,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if second_brain_input is not None:
            _body_params = second_brain_input


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'APIKeyHeader'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/v1/second-brain/spovs',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )


