# coding: utf-8

"""
    Gitea API

    This documentation describes the Gitea API.

    The version of the OpenAPI document: 1.24.5
    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 datetime import datetime
from pydantic import Field, StrictBool, StrictInt, StrictStr, field_validator
from typing import List, Optional
from typing_extensions import Annotated
from py_gitea_opensuse_org.models.notification_count import NotificationCount
from py_gitea_opensuse_org.models.notification_thread import NotificationThread

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


class NotificationApi:
    """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
    async def notify_get_list(
        self,
        all: Annotated[Optional[StrictBool], Field(description="If true, show notifications marked as read. Default value is false")] = None,
        status_types: Annotated[Optional[List[StrictStr]], Field(description="Show notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread & pinned.")] = None,
        subject_type: Annotated[Optional[List[StrictStr]], Field(description="filter notifications by subject type")] = None,
        since: Annotated[Optional[datetime], Field(description="Only show notifications updated after the given time. This is a timestamp in RFC 3339 format")] = None,
        before: Annotated[Optional[datetime], Field(description="Only show notifications updated before the given time. This is a timestamp in RFC 3339 format")] = None,
        page: Annotated[Optional[StrictInt], Field(description="page number of results to return (1-based)")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="page size of results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> List[NotificationThread]:
        """List users's notification threads


        :param all: If true, show notifications marked as read. Default value is false
        :type all: bool
        :param status_types: Show notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread & pinned.
        :type status_types: List[str]
        :param subject_type: filter notifications by subject type
        :type subject_type: List[str]
        :param since: Only show notifications updated after the given time. This is a timestamp in RFC 3339 format
        :type since: datetime
        :param before: Only show notifications updated before the given time. This is a timestamp in RFC 3339 format
        :type before: datetime
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_get_list_serialize(
            all=all,
            status_types=status_types,
            subject_type=subject_type,
            since=since,
            before=before,
            page=page,
            limit=limit,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    @validate_call
    async def notify_get_list_with_http_info(
        self,
        all: Annotated[Optional[StrictBool], Field(description="If true, show notifications marked as read. Default value is false")] = None,
        status_types: Annotated[Optional[List[StrictStr]], Field(description="Show notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread & pinned.")] = None,
        subject_type: Annotated[Optional[List[StrictStr]], Field(description="filter notifications by subject type")] = None,
        since: Annotated[Optional[datetime], Field(description="Only show notifications updated after the given time. This is a timestamp in RFC 3339 format")] = None,
        before: Annotated[Optional[datetime], Field(description="Only show notifications updated before the given time. This is a timestamp in RFC 3339 format")] = None,
        page: Annotated[Optional[StrictInt], Field(description="page number of results to return (1-based)")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="page size of results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[List[NotificationThread]]:
        """List users's notification threads


        :param all: If true, show notifications marked as read. Default value is false
        :type all: bool
        :param status_types: Show notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread & pinned.
        :type status_types: List[str]
        :param subject_type: filter notifications by subject type
        :type subject_type: List[str]
        :param since: Only show notifications updated after the given time. This is a timestamp in RFC 3339 format
        :type since: datetime
        :param before: Only show notifications updated before the given time. This is a timestamp in RFC 3339 format
        :type before: datetime
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_get_list_serialize(
            all=all,
            status_types=status_types,
            subject_type=subject_type,
            since=since,
            before=before,
            page=page,
            limit=limit,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    @validate_call
    async def notify_get_list_without_preload_content(
        self,
        all: Annotated[Optional[StrictBool], Field(description="If true, show notifications marked as read. Default value is false")] = None,
        status_types: Annotated[Optional[List[StrictStr]], Field(description="Show notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread & pinned.")] = None,
        subject_type: Annotated[Optional[List[StrictStr]], Field(description="filter notifications by subject type")] = None,
        since: Annotated[Optional[datetime], Field(description="Only show notifications updated after the given time. This is a timestamp in RFC 3339 format")] = None,
        before: Annotated[Optional[datetime], Field(description="Only show notifications updated before the given time. This is a timestamp in RFC 3339 format")] = None,
        page: Annotated[Optional[StrictInt], Field(description="page number of results to return (1-based)")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="page size of results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """List users's notification threads


        :param all: If true, show notifications marked as read. Default value is false
        :type all: bool
        :param status_types: Show notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread & pinned.
        :type status_types: List[str]
        :param subject_type: filter notifications by subject type
        :type subject_type: List[str]
        :param since: Only show notifications updated after the given time. This is a timestamp in RFC 3339 format
        :type since: datetime
        :param before: Only show notifications updated before the given time. This is a timestamp in RFC 3339 format
        :type before: datetime
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_get_list_serialize(
            all=all,
            status_types=status_types,
            subject_type=subject_type,
            since=since,
            before=before,
            page=page,
            limit=limit,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    def _notify_get_list_serialize(
        self,
        all,
        status_types,
        subject_type,
        since,
        before,
        page,
        limit,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'status-types': 'multi',
            'subject-type': 'multi',
        }

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

        # process the path parameters
        # process the query parameters
        if all is not None:
            
            _query_params.append(('all', all))
            
        if status_types is not None:
            
            _query_params.append(('status-types', status_types))
            
        if subject_type is not None:
            
            _query_params.append(('subject-type', subject_type))
            
        if since is not None:
            if isinstance(since, datetime):
                _query_params.append(
                    (
                        'since',
                        since.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('since', since))
            
        if before is not None:
            if isinstance(before, datetime):
                _query_params.append(
                    (
                        'before',
                        before.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('before', before))
            
        if page is not None:
            
            _query_params.append(('page', page))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        # 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] = [
            'TOTPHeader', 
            'AuthorizationHeaderToken', 
            'SudoHeader', 
            'BasicAuth', 
            'AccessToken', 
            'SudoParam', 
            'Token'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/notifications',
            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
    async def notify_get_repo_list(
        self,
        owner: Annotated[StrictStr, Field(description="owner of the repo")],
        repo: Annotated[StrictStr, Field(description="name of the repo")],
        all: Annotated[Optional[StrictBool], Field(description="If true, show notifications marked as read. Default value is false")] = None,
        status_types: Annotated[Optional[List[StrictStr]], Field(description="Show notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread & pinned")] = None,
        subject_type: Annotated[Optional[List[StrictStr]], Field(description="filter notifications by subject type")] = None,
        since: Annotated[Optional[datetime], Field(description="Only show notifications updated after the given time. This is a timestamp in RFC 3339 format")] = None,
        before: Annotated[Optional[datetime], Field(description="Only show notifications updated before the given time. This is a timestamp in RFC 3339 format")] = None,
        page: Annotated[Optional[StrictInt], Field(description="page number of results to return (1-based)")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="page size of results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> List[NotificationThread]:
        """List users's notification threads on a specific repo


        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param all: If true, show notifications marked as read. Default value is false
        :type all: bool
        :param status_types: Show notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread & pinned
        :type status_types: List[str]
        :param subject_type: filter notifications by subject type
        :type subject_type: List[str]
        :param since: Only show notifications updated after the given time. This is a timestamp in RFC 3339 format
        :type since: datetime
        :param before: Only show notifications updated before the given time. This is a timestamp in RFC 3339 format
        :type before: datetime
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_get_repo_list_serialize(
            owner=owner,
            repo=repo,
            all=all,
            status_types=status_types,
            subject_type=subject_type,
            since=since,
            before=before,
            page=page,
            limit=limit,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    @validate_call
    async def notify_get_repo_list_with_http_info(
        self,
        owner: Annotated[StrictStr, Field(description="owner of the repo")],
        repo: Annotated[StrictStr, Field(description="name of the repo")],
        all: Annotated[Optional[StrictBool], Field(description="If true, show notifications marked as read. Default value is false")] = None,
        status_types: Annotated[Optional[List[StrictStr]], Field(description="Show notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread & pinned")] = None,
        subject_type: Annotated[Optional[List[StrictStr]], Field(description="filter notifications by subject type")] = None,
        since: Annotated[Optional[datetime], Field(description="Only show notifications updated after the given time. This is a timestamp in RFC 3339 format")] = None,
        before: Annotated[Optional[datetime], Field(description="Only show notifications updated before the given time. This is a timestamp in RFC 3339 format")] = None,
        page: Annotated[Optional[StrictInt], Field(description="page number of results to return (1-based)")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="page size of results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[List[NotificationThread]]:
        """List users's notification threads on a specific repo


        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param all: If true, show notifications marked as read. Default value is false
        :type all: bool
        :param status_types: Show notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread & pinned
        :type status_types: List[str]
        :param subject_type: filter notifications by subject type
        :type subject_type: List[str]
        :param since: Only show notifications updated after the given time. This is a timestamp in RFC 3339 format
        :type since: datetime
        :param before: Only show notifications updated before the given time. This is a timestamp in RFC 3339 format
        :type before: datetime
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_get_repo_list_serialize(
            owner=owner,
            repo=repo,
            all=all,
            status_types=status_types,
            subject_type=subject_type,
            since=since,
            before=before,
            page=page,
            limit=limit,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    @validate_call
    async def notify_get_repo_list_without_preload_content(
        self,
        owner: Annotated[StrictStr, Field(description="owner of the repo")],
        repo: Annotated[StrictStr, Field(description="name of the repo")],
        all: Annotated[Optional[StrictBool], Field(description="If true, show notifications marked as read. Default value is false")] = None,
        status_types: Annotated[Optional[List[StrictStr]], Field(description="Show notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread & pinned")] = None,
        subject_type: Annotated[Optional[List[StrictStr]], Field(description="filter notifications by subject type")] = None,
        since: Annotated[Optional[datetime], Field(description="Only show notifications updated after the given time. This is a timestamp in RFC 3339 format")] = None,
        before: Annotated[Optional[datetime], Field(description="Only show notifications updated before the given time. This is a timestamp in RFC 3339 format")] = None,
        page: Annotated[Optional[StrictInt], Field(description="page number of results to return (1-based)")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="page size of results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """List users's notification threads on a specific repo


        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param all: If true, show notifications marked as read. Default value is false
        :type all: bool
        :param status_types: Show notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread & pinned
        :type status_types: List[str]
        :param subject_type: filter notifications by subject type
        :type subject_type: List[str]
        :param since: Only show notifications updated after the given time. This is a timestamp in RFC 3339 format
        :type since: datetime
        :param before: Only show notifications updated before the given time. This is a timestamp in RFC 3339 format
        :type before: datetime
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_get_repo_list_serialize(
            owner=owner,
            repo=repo,
            all=all,
            status_types=status_types,
            subject_type=subject_type,
            since=since,
            before=before,
            page=page,
            limit=limit,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    def _notify_get_repo_list_serialize(
        self,
        owner,
        repo,
        all,
        status_types,
        subject_type,
        since,
        before,
        page,
        limit,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'status-types': 'multi',
            'subject-type': 'multi',
        }

        _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 owner is not None:
            _path_params['owner'] = owner
        if repo is not None:
            _path_params['repo'] = repo
        # process the query parameters
        if all is not None:
            
            _query_params.append(('all', all))
            
        if status_types is not None:
            
            _query_params.append(('status-types', status_types))
            
        if subject_type is not None:
            
            _query_params.append(('subject-type', subject_type))
            
        if since is not None:
            if isinstance(since, datetime):
                _query_params.append(
                    (
                        'since',
                        since.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('since', since))
            
        if before is not None:
            if isinstance(before, datetime):
                _query_params.append(
                    (
                        'before',
                        before.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('before', before))
            
        if page is not None:
            
            _query_params.append(('page', page))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        # 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] = [
            'TOTPHeader', 
            'AuthorizationHeaderToken', 
            'SudoHeader', 
            'BasicAuth', 
            'AccessToken', 
            'SudoParam', 
            'Token'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/repos/{owner}/{repo}/notifications',
            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
    async def notify_get_thread(
        self,
        id: Annotated[StrictStr, Field(description="id of notification thread")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> NotificationThread:
        """Get notification thread by ID


        :param id: id of notification thread (required)
        :type id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_get_thread_serialize(
            id=id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    @validate_call
    async def notify_get_thread_with_http_info(
        self,
        id: Annotated[StrictStr, Field(description="id of notification thread")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[NotificationThread]:
        """Get notification thread by ID


        :param id: id of notification thread (required)
        :type id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_get_thread_serialize(
            id=id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    @validate_call
    async def notify_get_thread_without_preload_content(
        self,
        id: Annotated[StrictStr, Field(description="id of notification thread")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Get notification thread by ID


        :param id: id of notification thread (required)
        :type id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_get_thread_serialize(
            id=id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    def _notify_get_thread_serialize(
        self,
        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 id is not None:
            _path_params['id'] = id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


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


        # authentication setting
        _auth_settings: List[str] = [
            'TOTPHeader', 
            'AuthorizationHeaderToken', 
            'SudoHeader', 
            'BasicAuth', 
            'AccessToken', 
            'SudoParam', 
            'Token'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/notifications/threads/{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
    async def notify_new_available(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> NotificationCount:
        """Check if unread notifications exist


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_new_available_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    @validate_call
    async def notify_new_available_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[NotificationCount]:
        """Check if unread notifications exist


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_new_available_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    @validate_call
    async def notify_new_available_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Check if unread notifications exist


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_new_available_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    def _notify_new_available_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', 
                    'text/html'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'TOTPHeader', 
            'AuthorizationHeaderToken', 
            'SudoHeader', 
            'BasicAuth', 
            'AccessToken', 
            'SudoParam', 
            'Token'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/notifications/new',
            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
    async def notify_read_list(
        self,
        last_read_at: Annotated[Optional[datetime], Field(description="Describes the last point that notifications were checked. Anything updated since this time will not be updated.")] = None,
        all: Annotated[Optional[StrictStr], Field(description="If true, mark all notifications on this repo. Default value is false")] = None,
        status_types: Annotated[Optional[List[StrictStr]], Field(description="Mark notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread.")] = None,
        to_status: Annotated[Optional[StrictStr], Field(description="Status to mark notifications as, Defaults to read.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> List[NotificationThread]:
        """Mark notification threads as read, pinned or unread


        :param last_read_at: Describes the last point that notifications were checked. Anything updated since this time will not be updated.
        :type last_read_at: datetime
        :param all: If true, mark all notifications on this repo. Default value is false
        :type all: str
        :param status_types: Mark notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread.
        :type status_types: List[str]
        :param to_status: Status to mark notifications as, Defaults to read.
        :type to_status: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_read_list_serialize(
            last_read_at=last_read_at,
            all=all,
            status_types=status_types,
            to_status=to_status,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    @validate_call
    async def notify_read_list_with_http_info(
        self,
        last_read_at: Annotated[Optional[datetime], Field(description="Describes the last point that notifications were checked. Anything updated since this time will not be updated.")] = None,
        all: Annotated[Optional[StrictStr], Field(description="If true, mark all notifications on this repo. Default value is false")] = None,
        status_types: Annotated[Optional[List[StrictStr]], Field(description="Mark notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread.")] = None,
        to_status: Annotated[Optional[StrictStr], Field(description="Status to mark notifications as, Defaults to read.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[List[NotificationThread]]:
        """Mark notification threads as read, pinned or unread


        :param last_read_at: Describes the last point that notifications were checked. Anything updated since this time will not be updated.
        :type last_read_at: datetime
        :param all: If true, mark all notifications on this repo. Default value is false
        :type all: str
        :param status_types: Mark notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread.
        :type status_types: List[str]
        :param to_status: Status to mark notifications as, Defaults to read.
        :type to_status: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_read_list_serialize(
            last_read_at=last_read_at,
            all=all,
            status_types=status_types,
            to_status=to_status,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    @validate_call
    async def notify_read_list_without_preload_content(
        self,
        last_read_at: Annotated[Optional[datetime], Field(description="Describes the last point that notifications were checked. Anything updated since this time will not be updated.")] = None,
        all: Annotated[Optional[StrictStr], Field(description="If true, mark all notifications on this repo. Default value is false")] = None,
        status_types: Annotated[Optional[List[StrictStr]], Field(description="Mark notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread.")] = None,
        to_status: Annotated[Optional[StrictStr], Field(description="Status to mark notifications as, Defaults to read.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Mark notification threads as read, pinned or unread


        :param last_read_at: Describes the last point that notifications were checked. Anything updated since this time will not be updated.
        :type last_read_at: datetime
        :param all: If true, mark all notifications on this repo. Default value is false
        :type all: str
        :param status_types: Mark notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread.
        :type status_types: List[str]
        :param to_status: Status to mark notifications as, Defaults to read.
        :type to_status: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_read_list_serialize(
            last_read_at=last_read_at,
            all=all,
            status_types=status_types,
            to_status=to_status,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    def _notify_read_list_serialize(
        self,
        last_read_at,
        all,
        status_types,
        to_status,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'status-types': 'multi',
        }

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

        # process the path parameters
        # process the query parameters
        if last_read_at is not None:
            if isinstance(last_read_at, datetime):
                _query_params.append(
                    (
                        'last_read_at',
                        last_read_at.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('last_read_at', last_read_at))
            
        if all is not None:
            
            _query_params.append(('all', all))
            
        if status_types is not None:
            
            _query_params.append(('status-types', status_types))
            
        if to_status is not None:
            
            _query_params.append(('to-status', to_status))
            
        # 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] = [
            'TOTPHeader', 
            'AuthorizationHeaderToken', 
            'SudoHeader', 
            'BasicAuth', 
            'AccessToken', 
            'SudoParam', 
            'Token'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/notifications',
            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
    async def notify_read_repo_list(
        self,
        owner: Annotated[StrictStr, Field(description="owner of the repo")],
        repo: Annotated[StrictStr, Field(description="name of the repo")],
        all: Annotated[Optional[StrictStr], Field(description="If true, mark all notifications on this repo. Default value is false")] = None,
        status_types: Annotated[Optional[List[StrictStr]], Field(description="Mark notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread.")] = None,
        to_status: Annotated[Optional[StrictStr], Field(description="Status to mark notifications as. Defaults to read.")] = None,
        last_read_at: Annotated[Optional[datetime], Field(description="Describes the last point that notifications were checked. Anything updated since this time will not be updated.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> List[NotificationThread]:
        """Mark notification threads as read, pinned or unread on a specific repo


        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param all: If true, mark all notifications on this repo. Default value is false
        :type all: str
        :param status_types: Mark notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread.
        :type status_types: List[str]
        :param to_status: Status to mark notifications as. Defaults to read.
        :type to_status: str
        :param last_read_at: Describes the last point that notifications were checked. Anything updated since this time will not be updated.
        :type last_read_at: datetime
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_read_repo_list_serialize(
            owner=owner,
            repo=repo,
            all=all,
            status_types=status_types,
            to_status=to_status,
            last_read_at=last_read_at,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    @validate_call
    async def notify_read_repo_list_with_http_info(
        self,
        owner: Annotated[StrictStr, Field(description="owner of the repo")],
        repo: Annotated[StrictStr, Field(description="name of the repo")],
        all: Annotated[Optional[StrictStr], Field(description="If true, mark all notifications on this repo. Default value is false")] = None,
        status_types: Annotated[Optional[List[StrictStr]], Field(description="Mark notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread.")] = None,
        to_status: Annotated[Optional[StrictStr], Field(description="Status to mark notifications as. Defaults to read.")] = None,
        last_read_at: Annotated[Optional[datetime], Field(description="Describes the last point that notifications were checked. Anything updated since this time will not be updated.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[List[NotificationThread]]:
        """Mark notification threads as read, pinned or unread on a specific repo


        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param all: If true, mark all notifications on this repo. Default value is false
        :type all: str
        :param status_types: Mark notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread.
        :type status_types: List[str]
        :param to_status: Status to mark notifications as. Defaults to read.
        :type to_status: str
        :param last_read_at: Describes the last point that notifications were checked. Anything updated since this time will not be updated.
        :type last_read_at: datetime
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_read_repo_list_serialize(
            owner=owner,
            repo=repo,
            all=all,
            status_types=status_types,
            to_status=to_status,
            last_read_at=last_read_at,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    @validate_call
    async def notify_read_repo_list_without_preload_content(
        self,
        owner: Annotated[StrictStr, Field(description="owner of the repo")],
        repo: Annotated[StrictStr, Field(description="name of the repo")],
        all: Annotated[Optional[StrictStr], Field(description="If true, mark all notifications on this repo. Default value is false")] = None,
        status_types: Annotated[Optional[List[StrictStr]], Field(description="Mark notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread.")] = None,
        to_status: Annotated[Optional[StrictStr], Field(description="Status to mark notifications as. Defaults to read.")] = None,
        last_read_at: Annotated[Optional[datetime], Field(description="Describes the last point that notifications were checked. Anything updated since this time will not be updated.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Mark notification threads as read, pinned or unread on a specific repo


        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param all: If true, mark all notifications on this repo. Default value is false
        :type all: str
        :param status_types: Mark notifications with the provided status types. Options are: unread, read and/or pinned. Defaults to unread.
        :type status_types: List[str]
        :param to_status: Status to mark notifications as. Defaults to read.
        :type to_status: str
        :param last_read_at: Describes the last point that notifications were checked. Anything updated since this time will not be updated.
        :type last_read_at: datetime
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_read_repo_list_serialize(
            owner=owner,
            repo=repo,
            all=all,
            status_types=status_types,
            to_status=to_status,
            last_read_at=last_read_at,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    def _notify_read_repo_list_serialize(
        self,
        owner,
        repo,
        all,
        status_types,
        to_status,
        last_read_at,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'status-types': 'multi',
        }

        _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 owner is not None:
            _path_params['owner'] = owner
        if repo is not None:
            _path_params['repo'] = repo
        # process the query parameters
        if all is not None:
            
            _query_params.append(('all', all))
            
        if status_types is not None:
            
            _query_params.append(('status-types', status_types))
            
        if to_status is not None:
            
            _query_params.append(('to-status', to_status))
            
        if last_read_at is not None:
            if isinstance(last_read_at, datetime):
                _query_params.append(
                    (
                        'last_read_at',
                        last_read_at.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('last_read_at', last_read_at))
            
        # 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] = [
            'TOTPHeader', 
            'AuthorizationHeaderToken', 
            'SudoHeader', 
            'BasicAuth', 
            'AccessToken', 
            'SudoParam', 
            'Token'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/repos/{owner}/{repo}/notifications',
            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
    async def notify_read_thread(
        self,
        id: Annotated[StrictStr, Field(description="id of notification thread")],
        to_status: Annotated[Optional[StrictStr], Field(description="Status to mark notifications as")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> NotificationThread:
        """Mark notification thread as read by ID


        :param id: id of notification thread (required)
        :type id: str
        :param to_status: Status to mark notifications as
        :type to_status: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_read_thread_serialize(
            id=id,
            to_status=to_status,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    @validate_call
    async def notify_read_thread_with_http_info(
        self,
        id: Annotated[StrictStr, Field(description="id of notification thread")],
        to_status: Annotated[Optional[StrictStr], Field(description="Status to mark notifications as")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[NotificationThread]:
        """Mark notification thread as read by ID


        :param id: id of notification thread (required)
        :type id: str
        :param to_status: Status to mark notifications as
        :type to_status: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_read_thread_serialize(
            id=id,
            to_status=to_status,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

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


    @validate_call
    async def notify_read_thread_without_preload_content(
        self,
        id: Annotated[StrictStr, Field(description="id of notification thread")],
        to_status: Annotated[Optional[StrictStr], Field(description="Status to mark notifications as")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Mark notification thread as read by ID


        :param id: id of notification thread (required)
        :type id: str
        :param to_status: Status to mark notifications as
        :type to_status: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._notify_read_thread_serialize(
            id=id,
            to_status=to_status,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '205': "NotificationThread",
            '403': None,
            '404': None,
        }
        response_data = await self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _notify_read_thread_serialize(
        self,
        id,
        to_status,
        _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 id is not None:
            _path_params['id'] = id
        # process the query parameters
        if to_status is not None:
            
            _query_params.append(('to-status', to_status))
            
        # 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] = [
            'TOTPHeader', 
            'AuthorizationHeaderToken', 
            'SudoHeader', 
            'BasicAuth', 
            'AccessToken', 
            'SudoParam', 
            'Token'
        ]

        return self.api_client.param_serialize(
            method='PATCH',
            resource_path='/notifications/threads/{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
        )


