# 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 Field, StrictStr
from typing import Any, Dict, List, Optional
from typing_extensions import Annotated
from ephor_server_ti_client.models.body_export_data_api_v1_projects_project_id_export_post import BodyExportDataApiV1ProjectsProjectIdExportPost
from ephor_server_ti_client.models.channel import Channel
from ephor_server_ti_client.models.channel_create import ChannelCreate
from ephor_server_ti_client.models.channel_message import ChannelMessage
from ephor_server_ti_client.models.channel_update import ChannelUpdate
from ephor_server_ti_client.models.comment import Comment
from ephor_server_ti_client.models.create_channel200_response import CreateChannel200Response
from ephor_server_ti_client.models.project import Project
from ephor_server_ti_client.models.project_add_user_response import ProjectAddUserResponse
from ephor_server_ti_client.models.project_create import ProjectCreate
from ephor_server_ti_client.models.project_detail_response_input import ProjectDetailResponseInput
from ephor_server_ti_client.models.project_list_response import ProjectListResponse
from ephor_server_ti_client.models.project_onboard_response import ProjectOnboardResponse
from ephor_server_ti_client.models.project_remove_user_response import ProjectRemoveUserResponse
from ephor_server_ti_client.models.project_response import ProjectResponse
from ephor_server_ti_client.models.project_update import ProjectUpdate
from ephor_server_ti_client.models.recent_items_response import RecentItemsResponse

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 ProjectsApi:
    """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 accept_invitation_api_v1_projects_invite_email_invite_id_post(
        self,
        invite_id: StrictStr,
    ) -> ProjectAddUserResponse:
        """Accept Invitation


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectAddUserResponse",
            '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 accept_invitation_api_v1_projects_invite_email_invite_id_post_with_http_info(
        self,
        invite_id: StrictStr,
    ) -> ApiResponse[ProjectAddUserResponse]:
        """Accept Invitation


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectAddUserResponse",
            '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 accept_invitation_api_v1_projects_invite_email_invite_id_post_without_preload_content(
        self,
        invite_id: StrictStr,
    ) -> RESTResponseType:
        """Accept Invitation


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

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

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


    def _accept_invitation_api_v1_projects_invite_email_invite_id_post_serialize(
        self,
        invite_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 invite_id is not None:
            _path_params['invite_id'] = invite_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='POST',
            resource_path='/api/v1/projects/invite/email/{invite_id}',
            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 add_comment_api_v1_projects_project_id_comments_post(
        self,
        project_id: StrictStr,
        comment: Comment,
    ) -> ProjectResponse:
        """Add Comment


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectResponse",
            '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 add_comment_api_v1_projects_project_id_comments_post_with_http_info(
        self,
        project_id: StrictStr,
        comment: Comment,
    ) -> ApiResponse[ProjectResponse]:
        """Add Comment


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectResponse",
            '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 add_comment_api_v1_projects_project_id_comments_post_without_preload_content(
        self,
        project_id: StrictStr,
        comment: Comment,
    ) -> RESTResponseType:
        """Add Comment


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

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

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


    def _add_comment_api_v1_projects_project_id_comments_post_serialize(
        self,
        project_id,
        comment,
        _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
        if comment is not None:
            _body_params = comment


        # 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/projects/{project_id}/comments',
            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 add_user_to_project_api_v1_projects_project_id_add_user_email_get(
        self,
        project_id: StrictStr,
        email: StrictStr,
    ) -> Channel:
        """Add User To Project


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Channel",
            '400': None,
            '404': None,
            '422': "HTTPValidationError",
            '500': 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 add_user_to_project_api_v1_projects_project_id_add_user_email_get_with_http_info(
        self,
        project_id: StrictStr,
        email: StrictStr,
    ) -> ApiResponse[Channel]:
        """Add User To Project


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Channel",
            '400': None,
            '404': None,
            '422': "HTTPValidationError",
            '500': 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 add_user_to_project_api_v1_projects_project_id_add_user_email_get_without_preload_content(
        self,
        project_id: StrictStr,
        email: StrictStr,
    ) -> RESTResponseType:
        """Add User To Project


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

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

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


    def _add_user_to_project_api_v1_projects_project_id_add_user_email_get_serialize(
        self,
        project_id,
        email,
        _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 email is not None:
            _path_params['email'] = email
        # 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/projects/{project_id}/add-user/{email}',
            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 clean_up_projects_api_v1_projects_clean_up_get(
        self,
    ) -> List[str]:
        """Clean Up Projects


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[str]",
        }
        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 clean_up_projects_api_v1_projects_clean_up_get_with_http_info(
        self,
    ) -> ApiResponse[List[str]]:
        """Clean Up Projects


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[str]",
        }
        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 clean_up_projects_api_v1_projects_clean_up_get_without_preload_content(
        self,
    ) -> RESTResponseType:
        """Clean Up Projects


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

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

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


    def _clean_up_projects_api_v1_projects_clean_up_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/projects/clean_up',
            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 create_channel_api_v1_projects_project_id_channels_post(
        self,
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
        channel_create: Optional[ChannelCreate] = None,
    ) -> CreateChannel200Response:
        """Create a new channel


        :param project_id: The id of the project (required)
        :type project_id: str
        :param channel_create:
        :type channel_create: ChannelCreate
        :return: Returns the result object.
        """ # noqa: E501

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CreateChannel200Response",
            '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 create_channel_api_v1_projects_project_id_channels_post_with_http_info(
        self,
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
        channel_create: Optional[ChannelCreate] = None,
    ) -> ApiResponse[CreateChannel200Response]:
        """Create a new channel


        :param project_id: The id of the project (required)
        :type project_id: str
        :param channel_create:
        :type channel_create: ChannelCreate
        :return: Returns the result object.
        """ # noqa: E501

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CreateChannel200Response",
            '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 create_channel_api_v1_projects_project_id_channels_post_without_preload_content(
        self,
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
        channel_create: Optional[ChannelCreate] = None,
    ) -> RESTResponseType:
        """Create a new channel


        :param project_id: The id of the project (required)
        :type project_id: str
        :param channel_create:
        :type channel_create: ChannelCreate
        :return: Returns the result object.
        """ # noqa: E501

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

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


    def _create_channel_api_v1_projects_project_id_channels_post_serialize(
        self,
        project_id,
        channel_create,
        _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
        if channel_create is not None:
            _body_params = channel_create


        # 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/projects/{project_id}/channels',
            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 create_project_api_v1_projects_post(
        self,
        project_create: ProjectCreate,
    ) -> ProjectResponse:
        """Create Project


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectResponse",
            '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 create_project_api_v1_projects_post_with_http_info(
        self,
        project_create: ProjectCreate,
    ) -> ApiResponse[ProjectResponse]:
        """Create Project


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectResponse",
            '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 create_project_api_v1_projects_post_without_preload_content(
        self,
        project_create: ProjectCreate,
    ) -> RESTResponseType:
        """Create Project


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

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

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


    def _create_project_api_v1_projects_post_serialize(
        self,
        project_create,
        _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 project_create is not None:
            _body_params = project_create


        # 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/projects/',
            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_channel_api_v1_projects_project_id_channels_channel_id_delete(
        self,
        channel_id: Annotated[StrictStr, Field(description="The id of the channel to delete")],
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
    ) -> Channel:
        """Delete a channel by ID


        :param channel_id: The id of the channel to delete (required)
        :type channel_id: str
        :param project_id: The id of the project (required)
        :type project_id: str
        :return: Returns the result object.
        """ # noqa: E501

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Channel",
            '404': None,
            '422': "HTTPValidationError",
            '500': 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_channel_api_v1_projects_project_id_channels_channel_id_delete_with_http_info(
        self,
        channel_id: Annotated[StrictStr, Field(description="The id of the channel to delete")],
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
    ) -> ApiResponse[Channel]:
        """Delete a channel by ID


        :param channel_id: The id of the channel to delete (required)
        :type channel_id: str
        :param project_id: The id of the project (required)
        :type project_id: str
        :return: Returns the result object.
        """ # noqa: E501

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Channel",
            '404': None,
            '422': "HTTPValidationError",
            '500': 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_channel_api_v1_projects_project_id_channels_channel_id_delete_without_preload_content(
        self,
        channel_id: Annotated[StrictStr, Field(description="The id of the channel to delete")],
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
    ) -> RESTResponseType:
        """Delete a channel by ID


        :param channel_id: The id of the channel to delete (required)
        :type channel_id: str
        :param project_id: The id of the project (required)
        :type project_id: str
        :return: Returns the result object.
        """ # noqa: E501

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

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


    def _delete_channel_api_v1_projects_project_id_channels_channel_id_delete_serialize(
        self,
        channel_id,
        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 channel_id is not None:
            _path_params['channel_id'] = channel_id
        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='DELETE',
            resource_path='/api/v1/projects/{project_id}/channels/{channel_id}',
            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_project_api_v1_projects_project_id_delete(
        self,
        project_id: StrictStr,
    ) -> ProjectResponse:
        """Delete Project


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectResponse",
            '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_project_api_v1_projects_project_id_delete_with_http_info(
        self,
        project_id: StrictStr,
    ) -> ApiResponse[ProjectResponse]:
        """Delete Project


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectResponse",
            '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_project_api_v1_projects_project_id_delete_without_preload_content(
        self,
        project_id: StrictStr,
    ) -> RESTResponseType:
        """Delete Project


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

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

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


    def _delete_project_api_v1_projects_project_id_delete_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='DELETE',
            resource_path='/api/v1/projects/{project_id}',
            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 edit_channel_api_v1_projects_project_id_channels_channel_id_put(
        self,
        project_id: StrictStr,
        channel_id: StrictStr,
        channel: Channel,
    ) -> Channel:
        """Edit Channel


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

        _param = self._edit_channel_api_v1_projects_project_id_channels_channel_id_put_serialize(
            project_id=project_id,
            channel_id=channel_id,
            channel=channel,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Channel",
            '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 edit_channel_api_v1_projects_project_id_channels_channel_id_put_with_http_info(
        self,
        project_id: StrictStr,
        channel_id: StrictStr,
        channel: Channel,
    ) -> ApiResponse[Channel]:
        """Edit Channel


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

        _param = self._edit_channel_api_v1_projects_project_id_channels_channel_id_put_serialize(
            project_id=project_id,
            channel_id=channel_id,
            channel=channel,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Channel",
            '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 edit_channel_api_v1_projects_project_id_channels_channel_id_put_without_preload_content(
        self,
        project_id: StrictStr,
        channel_id: StrictStr,
        channel: Channel,
    ) -> RESTResponseType:
        """Edit Channel


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

        _param = self._edit_channel_api_v1_projects_project_id_channels_channel_id_put_serialize(
            project_id=project_id,
            channel_id=channel_id,
            channel=channel,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

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


    def _edit_channel_api_v1_projects_project_id_channels_channel_id_put_serialize(
        self,
        project_id,
        channel_id,
        channel,
        _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 channel_id is not None:
            _path_params['channel_id'] = channel_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if channel is not None:
            _body_params = channel


        # 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='PUT',
            resource_path='/api/v1/projects/{project_id}/channels/{channel_id}',
            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 edit_project_api_v1_projects_project_id_put(
        self,
        project_id: StrictStr,
        project_update: ProjectUpdate,
        include_in_schema: Optional[Any] = None,
    ) -> ProjectResponse:
        """Edit Project

        Edit a project.  Args:     project_id (str): The ID of the project to edit.     project (ProjectUpdate): The updated project data.     auth (EndpointAuth): Authentication dependency that provides the current user's account ID.  Returns:     ProjectResponse: Response model indicating the result of the operation.

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

        _param = self._edit_project_api_v1_projects_project_id_put_serialize(
            project_id=project_id,
            project_update=project_update,
            include_in_schema=include_in_schema,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectResponse",
            '400': None,
            '403': None,
            '404': None,
            '409': None,
            '422': "HTTPValidationError",
            '500': 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 edit_project_api_v1_projects_project_id_put_with_http_info(
        self,
        project_id: StrictStr,
        project_update: ProjectUpdate,
        include_in_schema: Optional[Any] = None,
    ) -> ApiResponse[ProjectResponse]:
        """Edit Project

        Edit a project.  Args:     project_id (str): The ID of the project to edit.     project (ProjectUpdate): The updated project data.     auth (EndpointAuth): Authentication dependency that provides the current user's account ID.  Returns:     ProjectResponse: Response model indicating the result of the operation.

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

        _param = self._edit_project_api_v1_projects_project_id_put_serialize(
            project_id=project_id,
            project_update=project_update,
            include_in_schema=include_in_schema,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectResponse",
            '400': None,
            '403': None,
            '404': None,
            '409': None,
            '422': "HTTPValidationError",
            '500': 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 edit_project_api_v1_projects_project_id_put_without_preload_content(
        self,
        project_id: StrictStr,
        project_update: ProjectUpdate,
        include_in_schema: Optional[Any] = None,
    ) -> RESTResponseType:
        """Edit Project

        Edit a project.  Args:     project_id (str): The ID of the project to edit.     project (ProjectUpdate): The updated project data.     auth (EndpointAuth): Authentication dependency that provides the current user's account ID.  Returns:     ProjectResponse: Response model indicating the result of the operation.

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

        _param = self._edit_project_api_v1_projects_project_id_put_serialize(
            project_id=project_id,
            project_update=project_update,
            include_in_schema=include_in_schema,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

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


    def _edit_project_api_v1_projects_project_id_put_serialize(
        self,
        project_id,
        project_update,
        include_in_schema,
        _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
        if include_in_schema is not None:
            
            _query_params.append(('include_in_schema', include_in_schema))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if project_update is not None:
            _body_params = project_update


        # 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='PUT',
            resource_path='/api/v1/projects/{project_id}',
            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 export_data_api_v1_projects_project_id_export_post(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        body_export_data_api_v1_projects_project_id_export_post: BodyExportDataApiV1ProjectsProjectIdExportPost,
    ) -> None:
        """Export Data


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param body_export_data_api_v1_projects_project_id_export_post: (required)
        :type body_export_data_api_v1_projects_project_id_export_post: BodyExportDataApiV1ProjectsProjectIdExportPost
        :return: Returns the result object.
        """ # noqa: E501

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': 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 export_data_api_v1_projects_project_id_export_post_with_http_info(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        body_export_data_api_v1_projects_project_id_export_post: BodyExportDataApiV1ProjectsProjectIdExportPost,
    ) -> ApiResponse[None]:
        """Export Data


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param body_export_data_api_v1_projects_project_id_export_post: (required)
        :type body_export_data_api_v1_projects_project_id_export_post: BodyExportDataApiV1ProjectsProjectIdExportPost
        :return: Returns the result object.
        """ # noqa: E501

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': 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 export_data_api_v1_projects_project_id_export_post_without_preload_content(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        body_export_data_api_v1_projects_project_id_export_post: BodyExportDataApiV1ProjectsProjectIdExportPost,
    ) -> RESTResponseType:
        """Export Data


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param body_export_data_api_v1_projects_project_id_export_post: (required)
        :type body_export_data_api_v1_projects_project_id_export_post: BodyExportDataApiV1ProjectsProjectIdExportPost
        :return: Returns the result object.
        """ # noqa: E501

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

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


    def _export_data_api_v1_projects_project_id_export_post_serialize(
        self,
        project_id,
        body_export_data_api_v1_projects_project_id_export_post,
        _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
        if body_export_data_api_v1_projects_project_id_export_post is not None:
            _body_params = body_export_data_api_v1_projects_project_id_export_post


        # 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/projects/{project_id}/export',
            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 fork_channel_api_v1_projects_project_id_channels_channel_id_fork_post(
        self,
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
        channel_id: Annotated[StrictStr, Field(description="The id of the channel to fork")],
    ) -> Channel:
        """Fork a channel


        :param project_id: The id of the project (required)
        :type project_id: str
        :param channel_id: The id of the channel to fork (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Channel",
            '404': None,
            '422': "HTTPValidationError",
            '500': 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 fork_channel_api_v1_projects_project_id_channels_channel_id_fork_post_with_http_info(
        self,
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
        channel_id: Annotated[StrictStr, Field(description="The id of the channel to fork")],
    ) -> ApiResponse[Channel]:
        """Fork a channel


        :param project_id: The id of the project (required)
        :type project_id: str
        :param channel_id: The id of the channel to fork (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Channel",
            '404': None,
            '422': "HTTPValidationError",
            '500': 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 fork_channel_api_v1_projects_project_id_channels_channel_id_fork_post_without_preload_content(
        self,
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
        channel_id: Annotated[StrictStr, Field(description="The id of the channel to fork")],
    ) -> RESTResponseType:
        """Fork a channel


        :param project_id: The id of the project (required)
        :type project_id: str
        :param channel_id: The id of the channel to fork (required)
        :type channel_id: str
        :return: Returns the result object.
        """ # noqa: E501

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

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


    def _fork_channel_api_v1_projects_project_id_channels_channel_id_fork_post_serialize(
        self,
        project_id,
        channel_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 channel_id is not None:
            _path_params['channel_id'] = channel_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='POST',
            resource_path='/api/v1/projects/{project_id}/channels/{channel_id}/fork',
            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 generate_guided_queries_api_v1_projects_project_id_generate_queries_post(
        self,
        project_id: StrictStr,
        channel_message: List[ChannelMessage],
    ) -> List[str]:
        """Generate Guided Queries


        :param project_id: (required)
        :type project_id: str
        :param channel_message: (required)
        :type channel_message: List[ChannelMessage]
        :return: Returns the result object.
        """ # noqa: E501

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[str]",
            '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 generate_guided_queries_api_v1_projects_project_id_generate_queries_post_with_http_info(
        self,
        project_id: StrictStr,
        channel_message: List[ChannelMessage],
    ) -> ApiResponse[List[str]]:
        """Generate Guided Queries


        :param project_id: (required)
        :type project_id: str
        :param channel_message: (required)
        :type channel_message: List[ChannelMessage]
        :return: Returns the result object.
        """ # noqa: E501

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[str]",
            '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 generate_guided_queries_api_v1_projects_project_id_generate_queries_post_without_preload_content(
        self,
        project_id: StrictStr,
        channel_message: List[ChannelMessage],
    ) -> RESTResponseType:
        """Generate Guided Queries


        :param project_id: (required)
        :type project_id: str
        :param channel_message: (required)
        :type channel_message: List[ChannelMessage]
        :return: Returns the result object.
        """ # noqa: E501

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

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


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

        _host = None

        _collection_formats: Dict[str, str] = {
            'ChannelMessage': '',
        }

        _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
        if channel_message is not None:
            _body_params = channel_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/projects/{project_id}/generate_queries',
            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_channel_api_v1_projects_project_id_channels_channel_id_get(
        self,
        channel_id: Annotated[StrictStr, Field(description="The id of the channel to retrieve")],
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
    ) -> Channel:
        """Get a channel by ID


        :param channel_id: The id of the channel to retrieve (required)
        :type channel_id: str
        :param project_id: The id of the project (required)
        :type project_id: str
        :return: Returns the result object.
        """ # noqa: E501

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Channel",
            '404': None,
            '422': "HTTPValidationError",
            '500': 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 get_channel_api_v1_projects_project_id_channels_channel_id_get_with_http_info(
        self,
        channel_id: Annotated[StrictStr, Field(description="The id of the channel to retrieve")],
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
    ) -> ApiResponse[Channel]:
        """Get a channel by ID


        :param channel_id: The id of the channel to retrieve (required)
        :type channel_id: str
        :param project_id: The id of the project (required)
        :type project_id: str
        :return: Returns the result object.
        """ # noqa: E501

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Channel",
            '404': None,
            '422': "HTTPValidationError",
            '500': 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 get_channel_api_v1_projects_project_id_channels_channel_id_get_without_preload_content(
        self,
        channel_id: Annotated[StrictStr, Field(description="The id of the channel to retrieve")],
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
    ) -> RESTResponseType:
        """Get a channel by ID


        :param channel_id: The id of the channel to retrieve (required)
        :type channel_id: str
        :param project_id: The id of the project (required)
        :type project_id: str
        :return: Returns the result object.
        """ # noqa: E501

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

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


    def _get_channel_api_v1_projects_project_id_channels_channel_id_get_serialize(
        self,
        channel_id,
        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 channel_id is not None:
            _path_params['channel_id'] = channel_id
        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/projects/{project_id}/channels/{channel_id}',
            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_channel_messages_api_v1_projects_project_id_channels_channel_id_messages_get(
        self,
        channel_id: Annotated[StrictStr, Field(description="The id of the channel to retrieve")],
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
    ) -> List[ChannelMessage]:
        """Get messages for a channel


        :param channel_id: The id of the channel to retrieve (required)
        :type channel_id: str
        :param project_id: The id of the project (required)
        :type project_id: str
        :return: Returns the result object.
        """ # noqa: E501

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[ChannelMessage]",
            '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_channel_messages_api_v1_projects_project_id_channels_channel_id_messages_get_with_http_info(
        self,
        channel_id: Annotated[StrictStr, Field(description="The id of the channel to retrieve")],
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
    ) -> ApiResponse[List[ChannelMessage]]:
        """Get messages for a channel


        :param channel_id: The id of the channel to retrieve (required)
        :type channel_id: str
        :param project_id: The id of the project (required)
        :type project_id: str
        :return: Returns the result object.
        """ # noqa: E501

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[ChannelMessage]",
            '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_channel_messages_api_v1_projects_project_id_channels_channel_id_messages_get_without_preload_content(
        self,
        channel_id: Annotated[StrictStr, Field(description="The id of the channel to retrieve")],
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
    ) -> RESTResponseType:
        """Get messages for a channel


        :param channel_id: The id of the channel to retrieve (required)
        :type channel_id: str
        :param project_id: The id of the project (required)
        :type project_id: str
        :return: Returns the result object.
        """ # noqa: E501

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

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


    def _get_channel_messages_api_v1_projects_project_id_channels_channel_id_messages_get_serialize(
        self,
        channel_id,
        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 channel_id is not None:
            _path_params['channel_id'] = channel_id
        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/projects/{project_id}/channels/{channel_id}/messages',
            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_channels_api_v1_projects_project_id_channels_get(
        self,
        project_id: StrictStr,
    ) -> List[Channel]:
        """Get channels for a project


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

        _param = self._get_channels_api_v1_projects_project_id_channels_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': "List[Channel]",
            '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_channels_api_v1_projects_project_id_channels_get_with_http_info(
        self,
        project_id: StrictStr,
    ) -> ApiResponse[List[Channel]]:
        """Get channels for a project


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

        _param = self._get_channels_api_v1_projects_project_id_channels_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': "List[Channel]",
            '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_channels_api_v1_projects_project_id_channels_get_without_preload_content(
        self,
        project_id: StrictStr,
    ) -> RESTResponseType:
        """Get channels for a project


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

        _param = self._get_channels_api_v1_projects_project_id_channels_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': "List[Channel]",
            '422': "HTTPValidationError",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        return response_data.response


    def _get_channels_api_v1_projects_project_id_channels_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/projects/{project_id}/channels',
            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_expert_comments_api_v1_projects_project_id_channels_channel_id_messages_message_id_expert_comments_get(
        self,
        project_id: StrictStr,
        channel_id: StrictStr,
        message_id: StrictStr,
    ) -> List[object]:
        """Get Expert Comments

        Get expert comments for a specific message.

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

        _param = self._get_expert_comments_api_v1_projects_project_id_channels_channel_id_messages_message_id_expert_comments_get_serialize(
            project_id=project_id,
            channel_id=channel_id,
            message_id=message_id,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[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 get_expert_comments_api_v1_projects_project_id_channels_channel_id_messages_message_id_expert_comments_get_with_http_info(
        self,
        project_id: StrictStr,
        channel_id: StrictStr,
        message_id: StrictStr,
    ) -> ApiResponse[List[object]]:
        """Get Expert Comments

        Get expert comments for a specific message.

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

        _param = self._get_expert_comments_api_v1_projects_project_id_channels_channel_id_messages_message_id_expert_comments_get_serialize(
            project_id=project_id,
            channel_id=channel_id,
            message_id=message_id,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[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 get_expert_comments_api_v1_projects_project_id_channels_channel_id_messages_message_id_expert_comments_get_without_preload_content(
        self,
        project_id: StrictStr,
        channel_id: StrictStr,
        message_id: StrictStr,
    ) -> RESTResponseType:
        """Get Expert Comments

        Get expert comments for a specific message.

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

        _param = self._get_expert_comments_api_v1_projects_project_id_channels_channel_id_messages_message_id_expert_comments_get_serialize(
            project_id=project_id,
            channel_id=channel_id,
            message_id=message_id,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

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


    def _get_expert_comments_api_v1_projects_project_id_channels_channel_id_messages_message_id_expert_comments_get_serialize(
        self,
        project_id,
        channel_id,
        message_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 channel_id is not None:
            _path_params['channel_id'] = channel_id
        if message_id is not None:
            _path_params['message_id'] = message_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/projects/{project_id}/channels/{channel_id}/messages/{message_id}/expert-comments',
            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_project_api_v1_projects_project_id_get(
        self,
        project_id: StrictStr,
    ) -> ProjectDetailResponseInput:
        """Get Project


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

        _param = self._get_project_api_v1_projects_project_id_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': "ProjectDetailResponseInput",
            '403': None,
            '404': None,
            '422': "HTTPValidationError",
            '500': 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 get_project_api_v1_projects_project_id_get_with_http_info(
        self,
        project_id: StrictStr,
    ) -> ApiResponse[ProjectDetailResponseInput]:
        """Get Project


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

        _param = self._get_project_api_v1_projects_project_id_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': "ProjectDetailResponseInput",
            '403': None,
            '404': None,
            '422': "HTTPValidationError",
            '500': 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 get_project_api_v1_projects_project_id_get_without_preload_content(
        self,
        project_id: StrictStr,
    ) -> RESTResponseType:
        """Get Project


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

        _param = self._get_project_api_v1_projects_project_id_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': "ProjectDetailResponseInput",
            '403': None,
            '404': None,
            '422': "HTTPValidationError",
            '500': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=None
        )
        return response_data.response


    def _get_project_api_v1_projects_project_id_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/projects/{project_id}',
            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_projects_api_v1_projects_get(
        self,
    ) -> List[ProjectListResponse]:
        """Get Projects


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[ProjectListResponse]",
        }
        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_projects_api_v1_projects_get_with_http_info(
        self,
    ) -> ApiResponse[List[ProjectListResponse]]:
        """Get Projects


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[ProjectListResponse]",
        }
        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_projects_api_v1_projects_get_without_preload_content(
        self,
    ) -> RESTResponseType:
        """Get Projects


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

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

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


    def _get_projects_api_v1_projects_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/projects/',
            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_recent_chats_api_v1_projects_recentchats_get(
        self,
    ) -> List[object]:
        """Get Recent Chats


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[object]",
        }
        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_recent_chats_api_v1_projects_recentchats_get_with_http_info(
        self,
    ) -> ApiResponse[List[object]]:
        """Get Recent Chats


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[object]",
        }
        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_recent_chats_api_v1_projects_recentchats_get_without_preload_content(
        self,
    ) -> RESTResponseType:
        """Get Recent Chats


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

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

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


    def _get_recent_chats_api_v1_projects_recentchats_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/projects/recentchats',
            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_recent_items_api_v1_projects_recentitems_get(
        self,
    ) -> RecentItemsResponse:
        """Get Recent Items


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "RecentItemsResponse",
        }
        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_recent_items_api_v1_projects_recentitems_get_with_http_info(
        self,
    ) -> ApiResponse[RecentItemsResponse]:
        """Get Recent Items


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "RecentItemsResponse",
        }
        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_recent_items_api_v1_projects_recentitems_get_without_preload_content(
        self,
    ) -> RESTResponseType:
        """Get Recent Items


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

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

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


    def _get_recent_items_api_v1_projects_recentitems_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/projects/recentitems',
            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_recent_projects_api_v1_projects_recentprojects_get(
        self,
    ) -> List[Project]:
        """Get Recent Projects


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[Project]",
        }
        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_recent_projects_api_v1_projects_recentprojects_get_with_http_info(
        self,
    ) -> ApiResponse[List[Project]]:
        """Get Recent Projects


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "List[Project]",
        }
        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_recent_projects_api_v1_projects_recentprojects_get_without_preload_content(
        self,
    ) -> RESTResponseType:
        """Get Recent Projects


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

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

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


    def _get_recent_projects_api_v1_projects_recentprojects_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/projects/recentprojects',
            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 join_project_api_v1_projects_invite_join_invite_link_id_post(
        self,
        invite_link_id: StrictStr,
    ) -> ProjectAddUserResponse:
        """Join Project


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectAddUserResponse",
            '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 join_project_api_v1_projects_invite_join_invite_link_id_post_with_http_info(
        self,
        invite_link_id: StrictStr,
    ) -> ApiResponse[ProjectAddUserResponse]:
        """Join Project


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectAddUserResponse",
            '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 join_project_api_v1_projects_invite_join_invite_link_id_post_without_preload_content(
        self,
        invite_link_id: StrictStr,
    ) -> RESTResponseType:
        """Join Project


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

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

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


    def _join_project_api_v1_projects_invite_join_invite_link_id_post_serialize(
        self,
        invite_link_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 invite_link_id is not None:
            _path_params['invite_link_id'] = invite_link_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='POST',
            resource_path='/api/v1/projects/invite/join/{invite_link_id}',
            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 onboard_user_api_v1_projects_onboard_user_post(
        self,
    ) -> ProjectOnboardResponse:
        """Onboard User


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectOnboardResponse",
        }
        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 onboard_user_api_v1_projects_onboard_user_post_with_http_info(
        self,
    ) -> ApiResponse[ProjectOnboardResponse]:
        """Onboard User


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectOnboardResponse",
        }
        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 onboard_user_api_v1_projects_onboard_user_post_without_preload_content(
        self,
    ) -> RESTResponseType:
        """Onboard User


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

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

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


    def _onboard_user_api_v1_projects_onboard_user_post_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='POST',
            resource_path='/api/v1/projects/onboard-user',
            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 pin_expert_comment_api_v1_projects_project_id_channels_channel_id_messages_message_id_expert_comments_comment_id_pin_post(
        self,
        project_id: StrictStr,
        channel_id: StrictStr,
        message_id: StrictStr,
        comment_id: StrictStr,
    ) -> object:
        """Pin Expert Comment

        Pin or unpin an expert comment.

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

        _param = self._pin_expert_comment_api_v1_projects_project_id_channels_channel_id_messages_message_id_expert_comments_comment_id_pin_post_serialize(
            project_id=project_id,
            channel_id=channel_id,
            message_id=message_id,
            comment_id=comment_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 pin_expert_comment_api_v1_projects_project_id_channels_channel_id_messages_message_id_expert_comments_comment_id_pin_post_with_http_info(
        self,
        project_id: StrictStr,
        channel_id: StrictStr,
        message_id: StrictStr,
        comment_id: StrictStr,
    ) -> ApiResponse[object]:
        """Pin Expert Comment

        Pin or unpin an expert comment.

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

        _param = self._pin_expert_comment_api_v1_projects_project_id_channels_channel_id_messages_message_id_expert_comments_comment_id_pin_post_serialize(
            project_id=project_id,
            channel_id=channel_id,
            message_id=message_id,
            comment_id=comment_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 pin_expert_comment_api_v1_projects_project_id_channels_channel_id_messages_message_id_expert_comments_comment_id_pin_post_without_preload_content(
        self,
        project_id: StrictStr,
        channel_id: StrictStr,
        message_id: StrictStr,
        comment_id: StrictStr,
    ) -> RESTResponseType:
        """Pin Expert Comment

        Pin or unpin an expert comment.

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

        _param = self._pin_expert_comment_api_v1_projects_project_id_channels_channel_id_messages_message_id_expert_comments_comment_id_pin_post_serialize(
            project_id=project_id,
            channel_id=channel_id,
            message_id=message_id,
            comment_id=comment_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 _pin_expert_comment_api_v1_projects_project_id_channels_channel_id_messages_message_id_expert_comments_comment_id_pin_post_serialize(
        self,
        project_id,
        channel_id,
        message_id,
        comment_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 channel_id is not None:
            _path_params['channel_id'] = channel_id
        if message_id is not None:
            _path_params['message_id'] = message_id
        if comment_id is not None:
            _path_params['comment_id'] = comment_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='POST',
            resource_path='/api/v1/projects/{project_id}/channels/{channel_id}/messages/{message_id}/expert-comments/{comment_id}/pin',
            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 remove_user_from_project_api_v1_projects_project_id_remove_user_target_account_id_delete(
        self,
        project_id: StrictStr,
        target_account_id: StrictStr,
    ) -> ProjectRemoveUserResponse:
        """Remove User From Project

        Remove a user from a project.  Args:     project_id (str): The ID of the project.     target_account_id (str): The account ID of the user to remove.     auth (EndpointAuth): Authentication dependency that provides the current user's account ID.  Returns:     ProjectRemoveUserResponse: Response model indicating the result of the operation.

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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectRemoveUserResponse",
            '403': None,
            '404': None,
            '422': "HTTPValidationError",
            '500': 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 remove_user_from_project_api_v1_projects_project_id_remove_user_target_account_id_delete_with_http_info(
        self,
        project_id: StrictStr,
        target_account_id: StrictStr,
    ) -> ApiResponse[ProjectRemoveUserResponse]:
        """Remove User From Project

        Remove a user from a project.  Args:     project_id (str): The ID of the project.     target_account_id (str): The account ID of the user to remove.     auth (EndpointAuth): Authentication dependency that provides the current user's account ID.  Returns:     ProjectRemoveUserResponse: Response model indicating the result of the operation.

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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectRemoveUserResponse",
            '403': None,
            '404': None,
            '422': "HTTPValidationError",
            '500': 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 remove_user_from_project_api_v1_projects_project_id_remove_user_target_account_id_delete_without_preload_content(
        self,
        project_id: StrictStr,
        target_account_id: StrictStr,
    ) -> RESTResponseType:
        """Remove User From Project

        Remove a user from a project.  Args:     project_id (str): The ID of the project.     target_account_id (str): The account ID of the user to remove.     auth (EndpointAuth): Authentication dependency that provides the current user's account ID.  Returns:     ProjectRemoveUserResponse: Response model indicating the result of the operation.

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

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

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


    def _remove_user_from_project_api_v1_projects_project_id_remove_user_target_account_id_delete_serialize(
        self,
        project_id,
        target_account_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 target_account_id is not None:
            _path_params['target_account_id'] = target_account_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/projects/{project_id}/remove-user/{target_account_id}',
            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 restore_project_api_v1_projects_project_id_restore_post(
        self,
        project_id: StrictStr,
    ) -> ProjectResponse:
        """Restore Project


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectResponse",
            '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 restore_project_api_v1_projects_project_id_restore_post_with_http_info(
        self,
        project_id: StrictStr,
    ) -> ApiResponse[ProjectResponse]:
        """Restore Project


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectResponse",
            '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 restore_project_api_v1_projects_project_id_restore_post_without_preload_content(
        self,
        project_id: StrictStr,
    ) -> RESTResponseType:
        """Restore Project


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

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

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


    def _restore_project_api_v1_projects_project_id_restore_post_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='POST',
            resource_path='/api/v1/projects/{project_id}/restore',
            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 trash_project_api_v1_projects_project_id_trash_post(
        self,
        project_id: StrictStr,
    ) -> ProjectResponse:
        """Trash Project


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectResponse",
            '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 trash_project_api_v1_projects_project_id_trash_post_with_http_info(
        self,
        project_id: StrictStr,
    ) -> ApiResponse[ProjectResponse]:
        """Trash Project


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

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

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectResponse",
            '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 trash_project_api_v1_projects_project_id_trash_post_without_preload_content(
        self,
        project_id: StrictStr,
    ) -> RESTResponseType:
        """Trash Project


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

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

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


    def _trash_project_api_v1_projects_project_id_trash_post_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='POST',
            resource_path='/api/v1/projects/{project_id}/trash',
            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 update_artifact_published_url_api_v1_projects_project_id_channels_channel_id_artifacts_artifact_id_artifact_url_put(
        self,
        project_id: StrictStr,
        channel_id: StrictStr,
        artifact_id: StrictStr,
        artifact_url: StrictStr,
    ) -> None:
        """Update Artifact Published Url


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

        _param = self._update_artifact_published_url_api_v1_projects_project_id_channels_channel_id_artifacts_artifact_id_artifact_url_put_serialize(
            project_id=project_id,
            channel_id=channel_id,
            artifact_id=artifact_id,
            artifact_url=artifact_url,
            _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 update_artifact_published_url_api_v1_projects_project_id_channels_channel_id_artifacts_artifact_id_artifact_url_put_with_http_info(
        self,
        project_id: StrictStr,
        channel_id: StrictStr,
        artifact_id: StrictStr,
        artifact_url: StrictStr,
    ) -> ApiResponse[None]:
        """Update Artifact Published Url


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

        _param = self._update_artifact_published_url_api_v1_projects_project_id_channels_channel_id_artifacts_artifact_id_artifact_url_put_serialize(
            project_id=project_id,
            channel_id=channel_id,
            artifact_id=artifact_id,
            artifact_url=artifact_url,
            _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 update_artifact_published_url_api_v1_projects_project_id_channels_channel_id_artifacts_artifact_id_artifact_url_put_without_preload_content(
        self,
        project_id: StrictStr,
        channel_id: StrictStr,
        artifact_id: StrictStr,
        artifact_url: StrictStr,
    ) -> RESTResponseType:
        """Update Artifact Published Url


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

        _param = self._update_artifact_published_url_api_v1_projects_project_id_channels_channel_id_artifacts_artifact_id_artifact_url_put_serialize(
            project_id=project_id,
            channel_id=channel_id,
            artifact_id=artifact_id,
            artifact_url=artifact_url,
            _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 _update_artifact_published_url_api_v1_projects_project_id_channels_channel_id_artifacts_artifact_id_artifact_url_put_serialize(
        self,
        project_id,
        channel_id,
        artifact_id,
        artifact_url,
        _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 channel_id is not None:
            _path_params['channel_id'] = channel_id
        if artifact_id is not None:
            _path_params['artifact_id'] = artifact_id
        # process the query parameters
        if artifact_url is not None:
            
            _query_params.append(('artifact_url', artifact_url))
            
        # 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='PUT',
            resource_path='/api/v1/projects/{project_id}/channels/{channel_id}/artifacts/{artifact_id}/artifact_url',
            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 update_channel_name_api_v1_projects_project_id_channels_channel_id_patch(
        self,
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
        channel_id: Annotated[StrictStr, Field(description="The id of the channel to update")],
        channel_update: ChannelUpdate,
    ) -> Channel:
        """Update the channel name


        :param project_id: The id of the project (required)
        :type project_id: str
        :param channel_id: The id of the channel to update (required)
        :type channel_id: str
        :param channel_update: (required)
        :type channel_update: ChannelUpdate
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_channel_name_api_v1_projects_project_id_channels_channel_id_patch_serialize(
            project_id=project_id,
            channel_id=channel_id,
            channel_update=channel_update,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Channel",
            '400': None,
            '404': None,
            '422': "HTTPValidationError",
            '500': 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 update_channel_name_api_v1_projects_project_id_channels_channel_id_patch_with_http_info(
        self,
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
        channel_id: Annotated[StrictStr, Field(description="The id of the channel to update")],
        channel_update: ChannelUpdate,
    ) -> ApiResponse[Channel]:
        """Update the channel name


        :param project_id: The id of the project (required)
        :type project_id: str
        :param channel_id: The id of the channel to update (required)
        :type channel_id: str
        :param channel_update: (required)
        :type channel_update: ChannelUpdate
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_channel_name_api_v1_projects_project_id_channels_channel_id_patch_serialize(
            project_id=project_id,
            channel_id=channel_id,
            channel_update=channel_update,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Channel",
            '400': None,
            '404': None,
            '422': "HTTPValidationError",
            '500': 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 update_channel_name_api_v1_projects_project_id_channels_channel_id_patch_without_preload_content(
        self,
        project_id: Annotated[StrictStr, Field(description="The id of the project")],
        channel_id: Annotated[StrictStr, Field(description="The id of the channel to update")],
        channel_update: ChannelUpdate,
    ) -> RESTResponseType:
        """Update the channel name


        :param project_id: The id of the project (required)
        :type project_id: str
        :param channel_id: The id of the channel to update (required)
        :type channel_id: str
        :param channel_update: (required)
        :type channel_update: ChannelUpdate
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_channel_name_api_v1_projects_project_id_channels_channel_id_patch_serialize(
            project_id=project_id,
            channel_id=channel_id,
            channel_update=channel_update,
            _request_auth=None,
            _content_type=None,
            _headers=None,
            _host_index=0
        )

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


    def _update_channel_name_api_v1_projects_project_id_channels_channel_id_patch_serialize(
        self,
        project_id,
        channel_id,
        channel_update,
        _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 channel_id is not None:
            _path_params['channel_id'] = channel_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if channel_update is not None:
            _body_params = channel_update


        # 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='PATCH',
            resource_path='/api/v1/projects/{project_id}/channels/{channel_id}',
            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
        )


