# coding: utf-8

"""
    Gitea API.

    This documentation describes the Gitea API.

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

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


import re  # noqa: F401
import io
import warnings

from pydantic import validate_arguments, ValidationError
from typing_extensions import Annotated
from typing import overload, Optional, Union, Awaitable

from datetime import datetime

from pydantic import Field, StrictBool, StrictBytes, StrictInt, StrictStr

from typing import List, Optional, Union

from py_gitea_opensuse_org.models.add_time_option import AddTimeOption
from py_gitea_opensuse_org.models.attachment import Attachment
from py_gitea_opensuse_org.models.comment import Comment
from py_gitea_opensuse_org.models.create_issue_comment_option import CreateIssueCommentOption
from py_gitea_opensuse_org.models.create_issue_option import CreateIssueOption
from py_gitea_opensuse_org.models.create_label_option import CreateLabelOption
from py_gitea_opensuse_org.models.create_milestone_option import CreateMilestoneOption
from py_gitea_opensuse_org.models.edit_attachment_options import EditAttachmentOptions
from py_gitea_opensuse_org.models.edit_deadline_option import EditDeadlineOption
from py_gitea_opensuse_org.models.edit_issue_comment_option import EditIssueCommentOption
from py_gitea_opensuse_org.models.edit_issue_option import EditIssueOption
from py_gitea_opensuse_org.models.edit_label_option import EditLabelOption
from py_gitea_opensuse_org.models.edit_milestone_option import EditMilestoneOption
from py_gitea_opensuse_org.models.edit_reaction_option import EditReactionOption
from py_gitea_opensuse_org.models.issue import Issue
from py_gitea_opensuse_org.models.issue_deadline import IssueDeadline
from py_gitea_opensuse_org.models.issue_labels_option import IssueLabelsOption
from py_gitea_opensuse_org.models.label import Label
from py_gitea_opensuse_org.models.milestone import Milestone
from py_gitea_opensuse_org.models.reaction import Reaction
from py_gitea_opensuse_org.models.timeline_comment import TimelineComment
from py_gitea_opensuse_org.models.tracked_time import TrackedTime
from py_gitea_opensuse_org.models.user import User
from py_gitea_opensuse_org.models.watch_info import WatchInfo

from py_gitea_opensuse_org.api_client import ApiClient
from py_gitea_opensuse_org.api_response import ApiResponse
from py_gitea_opensuse_org.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class IssueApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client

    @overload
    async def issue_add_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], body : Optional[IssueLabelsOption] = None, **kwargs) -> List[Label]:  # noqa: E501
        ...

    @overload
    def issue_add_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], body : Optional[IssueLabelsOption] = None, async_req: Optional[bool]=True, **kwargs) -> List[Label]:  # noqa: E501
        ...

    @validate_arguments
    def issue_add_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], body : Optional[IssueLabelsOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[List[Label], Awaitable[List[Label]]]:  # noqa: E501
        """Add a label to an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_add_label(owner, repo, index, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param body:
        :type body: IssueLabelsOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[Label]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_add_label_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_add_label_with_http_info(owner, repo, index, body, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_add_label_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], body : Optional[IssueLabelsOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Add a label to an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_add_label_with_http_info(owner, repo, index, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param body:
        :type body: IssueLabelsOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[Label], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'body'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_add_label" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['body'] is not None:
            _body_params = _params['body']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '200': "List[Label]",
            '403': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/labels', 'POST',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_add_subscription(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], user : Annotated[StrictStr, Field(..., description="user to subscribe")], **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_add_subscription(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], user : Annotated[StrictStr, Field(..., description="user to subscribe")], async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_add_subscription(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], user : Annotated[StrictStr, Field(..., description="user to subscribe")], async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Subscribe user to issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_add_subscription(owner, repo, index, user, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param user: user to subscribe (required)
        :type user: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_add_subscription_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_add_subscription_with_http_info(owner, repo, index, user, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_add_subscription_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], user : Annotated[StrictStr, Field(..., description="user to subscribe")], **kwargs) -> ApiResponse:  # noqa: E501
        """Subscribe user to issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_add_subscription_with_http_info(owner, repo, index, user, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param user: user to subscribe (required)
        :type user: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'user'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_add_subscription" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']

        if _params['user']:
            _path_params['user'] = _params['user']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # authentication setting
        _auth_settings = ['TOTPHeader', 'AuthorizationHeaderToken', 'SudoHeader', 'BasicAuth', 'AccessToken', 'SudoParam', 'Token']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/subscriptions/{user}', 'PUT',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_add_time(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], body : Optional[AddTimeOption] = None, **kwargs) -> TrackedTime:  # noqa: E501
        ...

    @overload
    def issue_add_time(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], body : Optional[AddTimeOption] = None, async_req: Optional[bool]=True, **kwargs) -> TrackedTime:  # noqa: E501
        ...

    @validate_arguments
    def issue_add_time(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], body : Optional[AddTimeOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[TrackedTime, Awaitable[TrackedTime]]:  # noqa: E501
        """Add tracked time to a issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_add_time(owner, repo, index, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param body:
        :type body: AddTimeOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: TrackedTime
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_add_time_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_add_time_with_http_info(owner, repo, index, body, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_add_time_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], body : Optional[AddTimeOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Add tracked time to a issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_add_time_with_http_info(owner, repo, index, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param body:
        :type body: AddTimeOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(TrackedTime, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'body'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_add_time" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['body'] is not None:
            _body_params = _params['body']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '200': "TrackedTime",
            '400': None,
            '403': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/times', 'POST',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_check_subscription(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], **kwargs) -> WatchInfo:  # noqa: E501
        ...

    @overload
    def issue_check_subscription(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], async_req: Optional[bool]=True, **kwargs) -> WatchInfo:  # noqa: E501
        ...

    @validate_arguments
    def issue_check_subscription(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], async_req: Optional[bool]=None, **kwargs) -> Union[WatchInfo, Awaitable[WatchInfo]]:  # noqa: E501
        """Check if user is subscribed to an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_check_subscription(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: WatchInfo
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_check_subscription_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_check_subscription_with_http_info(owner, repo, index, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_check_subscription_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], **kwargs) -> ApiResponse:  # noqa: E501
        """Check if user is subscribed to an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_check_subscription_with_http_info(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(WatchInfo, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_check_subscription" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "WatchInfo",
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/subscriptions/check', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_clear_labels(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_clear_labels(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_clear_labels(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Remove all labels from an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_clear_labels(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_clear_labels_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_clear_labels_with_http_info(owner, repo, index, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_clear_labels_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], **kwargs) -> ApiResponse:  # noqa: E501
        """Remove all labels from an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_clear_labels_with_http_info(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_clear_labels" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # authentication setting
        _auth_settings = ['TOTPHeader', 'AuthorizationHeaderToken', 'SudoHeader', 'BasicAuth', 'AccessToken', 'SudoParam', 'Token']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/labels', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_create_comment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], body : Optional[CreateIssueCommentOption] = None, **kwargs) -> Comment:  # noqa: E501
        ...

    @overload
    def issue_create_comment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], body : Optional[CreateIssueCommentOption] = None, async_req: Optional[bool]=True, **kwargs) -> Comment:  # noqa: E501
        ...

    @validate_arguments
    def issue_create_comment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], body : Optional[CreateIssueCommentOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Comment, Awaitable[Comment]]:  # noqa: E501
        """Add a comment to an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_create_comment(owner, repo, index, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param body:
        :type body: CreateIssueCommentOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Comment
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_create_comment_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_create_comment_with_http_info(owner, repo, index, body, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_create_comment_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], body : Optional[CreateIssueCommentOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Add a comment to an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_create_comment_with_http_info(owner, repo, index, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param body:
        :type body: CreateIssueCommentOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Comment, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'body'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_create_comment" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['body'] is not None:
            _body_params = _params['body']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '201': "Comment",
            '403': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/comments', 'POST',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_create_issue(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], body : Optional[CreateIssueOption] = None, **kwargs) -> Issue:  # noqa: E501
        ...

    @overload
    def issue_create_issue(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], body : Optional[CreateIssueOption] = None, async_req: Optional[bool]=True, **kwargs) -> Issue:  # noqa: E501
        ...

    @validate_arguments
    def issue_create_issue(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], body : Optional[CreateIssueOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Issue, Awaitable[Issue]]:  # noqa: E501
        """Create an issue. If using deadline only the date will be taken into account, and time of day ignored.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_create_issue(owner, repo, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param body:
        :type body: CreateIssueOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Issue
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_create_issue_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_create_issue_with_http_info(owner, repo, body, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_create_issue_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], body : Optional[CreateIssueOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Create an issue. If using deadline only the date will be taken into account, and time of day ignored.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_create_issue_with_http_info(owner, repo, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param body:
        :type body: CreateIssueOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Issue, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'body'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_create_issue" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['body'] is not None:
            _body_params = _params['body']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '201': "Issue",
            '403': None,
            '412': None,
            '422': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues', 'POST',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_create_issue_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], attachment : Annotated[Union[StrictBytes, StrictStr], Field(..., description="attachment to upload")], name : Annotated[Optional[StrictStr], Field(description="name of the attachment")] = None, **kwargs) -> Attachment:  # noqa: E501
        ...

    @overload
    def issue_create_issue_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], attachment : Annotated[Union[StrictBytes, StrictStr], Field(..., description="attachment to upload")], name : Annotated[Optional[StrictStr], Field(description="name of the attachment")] = None, async_req: Optional[bool]=True, **kwargs) -> Attachment:  # noqa: E501
        ...

    @validate_arguments
    def issue_create_issue_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], attachment : Annotated[Union[StrictBytes, StrictStr], Field(..., description="attachment to upload")], name : Annotated[Optional[StrictStr], Field(description="name of the attachment")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Attachment, Awaitable[Attachment]]:  # noqa: E501
        """Create an issue attachment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_create_issue_attachment(owner, repo, index, attachment, name, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param attachment: attachment to upload (required)
        :type attachment: bytearray
        :param name: name of the attachment
        :type name: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Attachment
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_create_issue_attachment_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_create_issue_attachment_with_http_info(owner, repo, index, attachment, name, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_create_issue_attachment_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], attachment : Annotated[Union[StrictBytes, StrictStr], Field(..., description="attachment to upload")], name : Annotated[Optional[StrictStr], Field(description="name of the attachment")] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Create an issue attachment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_create_issue_attachment_with_http_info(owner, repo, index, attachment, name, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param attachment: attachment to upload (required)
        :type attachment: bytearray
        :param name: name of the attachment
        :type name: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Attachment, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'attachment',
            'name'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_create_issue_attachment" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        if _params.get('name') is not None:  # noqa: E501
            _query_params.append(('name', _params['name']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        if _params['attachment']:
            _files['attachment'] = _params['attachment']

        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['multipart/form-data']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '201': "Attachment",
            '400': None,
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/assets', 'POST',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_create_issue_comment_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], attachment : Annotated[Union[StrictBytes, StrictStr], Field(..., description="attachment to upload")], name : Annotated[Optional[StrictStr], Field(description="name of the attachment")] = None, **kwargs) -> Attachment:  # noqa: E501
        ...

    @overload
    def issue_create_issue_comment_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], attachment : Annotated[Union[StrictBytes, StrictStr], Field(..., description="attachment to upload")], name : Annotated[Optional[StrictStr], Field(description="name of the attachment")] = None, async_req: Optional[bool]=True, **kwargs) -> Attachment:  # noqa: E501
        ...

    @validate_arguments
    def issue_create_issue_comment_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], attachment : Annotated[Union[StrictBytes, StrictStr], Field(..., description="attachment to upload")], name : Annotated[Optional[StrictStr], Field(description="name of the attachment")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Attachment, Awaitable[Attachment]]:  # noqa: E501
        """Create a comment attachment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_create_issue_comment_attachment(owner, repo, id, attachment, name, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment (required)
        :type id: int
        :param attachment: attachment to upload (required)
        :type attachment: bytearray
        :param name: name of the attachment
        :type name: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Attachment
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_create_issue_comment_attachment_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_create_issue_comment_attachment_with_http_info(owner, repo, id, attachment, name, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_create_issue_comment_attachment_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], attachment : Annotated[Union[StrictBytes, StrictStr], Field(..., description="attachment to upload")], name : Annotated[Optional[StrictStr], Field(description="name of the attachment")] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Create a comment attachment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_create_issue_comment_attachment_with_http_info(owner, repo, id, attachment, name, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment (required)
        :type id: int
        :param attachment: attachment to upload (required)
        :type attachment: bytearray
        :param name: name of the attachment
        :type name: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Attachment, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id',
            'attachment',
            'name'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_create_issue_comment_attachment" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        if _params.get('name') is not None:  # noqa: E501
            _query_params.append(('name', _params['name']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        if _params['attachment']:
            _files['attachment'] = _params['attachment']

        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['multipart/form-data']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '201': "Attachment",
            '400': None,
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/comments/{id}/assets', 'POST',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_create_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], body : Optional[CreateLabelOption] = None, **kwargs) -> Label:  # noqa: E501
        ...

    @overload
    def issue_create_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], body : Optional[CreateLabelOption] = None, async_req: Optional[bool]=True, **kwargs) -> Label:  # noqa: E501
        ...

    @validate_arguments
    def issue_create_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], body : Optional[CreateLabelOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Label, Awaitable[Label]]:  # noqa: E501
        """Create a label  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_create_label(owner, repo, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param body:
        :type body: CreateLabelOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Label
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_create_label_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_create_label_with_http_info(owner, repo, body, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_create_label_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], body : Optional[CreateLabelOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Create a label  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_create_label_with_http_info(owner, repo, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param body:
        :type body: CreateLabelOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Label, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'body'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_create_label" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['body'] is not None:
            _body_params = _params['body']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '201': "Label",
            '422': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/labels', 'POST',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_create_milestone(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], body : Optional[CreateMilestoneOption] = None, **kwargs) -> Milestone:  # noqa: E501
        ...

    @overload
    def issue_create_milestone(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], body : Optional[CreateMilestoneOption] = None, async_req: Optional[bool]=True, **kwargs) -> Milestone:  # noqa: E501
        ...

    @validate_arguments
    def issue_create_milestone(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], body : Optional[CreateMilestoneOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Milestone, Awaitable[Milestone]]:  # noqa: E501
        """Create a milestone  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_create_milestone(owner, repo, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param body:
        :type body: CreateMilestoneOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Milestone
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_create_milestone_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_create_milestone_with_http_info(owner, repo, body, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_create_milestone_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], body : Optional[CreateMilestoneOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Create a milestone  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_create_milestone_with_http_info(owner, repo, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param body:
        :type body: CreateMilestoneOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Milestone, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'body'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_create_milestone" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['body'] is not None:
            _body_params = _params['body']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '201': "Milestone",
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/milestones', 'POST',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_delete(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of issue to delete")], **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_delete(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of issue to delete")], async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_delete(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of issue to delete")], async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Delete an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of issue to delete (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_delete_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_delete_with_http_info(owner, repo, index, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_delete_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of issue to delete")], **kwargs) -> ApiResponse:  # noqa: E501
        """Delete an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_with_http_info(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of issue to delete (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_delete" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # authentication setting
        _auth_settings = ['TOTPHeader', 'AuthorizationHeaderToken', 'SudoHeader', 'BasicAuth', 'AccessToken', 'SudoParam', 'Token']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_delete_comment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of comment to delete")], **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_delete_comment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of comment to delete")], async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_delete_comment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of comment to delete")], async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Delete a comment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_comment(owner, repo, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of comment to delete (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_delete_comment_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_delete_comment_with_http_info(owner, repo, id, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_delete_comment_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of comment to delete")], **kwargs) -> ApiResponse:  # noqa: E501
        """Delete a comment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_comment_with_http_info(owner, repo, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of comment to delete (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_delete_comment" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # authentication setting
        _auth_settings = ['TOTPHeader', 'AuthorizationHeaderToken', 'SudoHeader', 'BasicAuth', 'AccessToken', 'SudoParam', 'Token']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/comments/{id}', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_delete_comment_deprecated(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="this parameter is ignored")], id : Annotated[StrictInt, Field(..., description="id of comment to delete")], **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_delete_comment_deprecated(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="this parameter is ignored")], id : Annotated[StrictInt, Field(..., description="id of comment to delete")], async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_delete_comment_deprecated(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="this parameter is ignored")], id : Annotated[StrictInt, Field(..., description="id of comment to delete")], async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """(Deprecated) Delete a comment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_comment_deprecated(owner, repo, index, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: this parameter is ignored (required)
        :type index: int
        :param id: id of comment to delete (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_delete_comment_deprecated_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_delete_comment_deprecated_with_http_info(owner, repo, index, id, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_delete_comment_deprecated_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="this parameter is ignored")], id : Annotated[StrictInt, Field(..., description="id of comment to delete")], **kwargs) -> ApiResponse:  # noqa: E501
        """(Deprecated) Delete a comment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_comment_deprecated_with_http_info(owner, repo, index, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: this parameter is ignored (required)
        :type index: int
        :param id: id of comment to delete (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        warnings.warn("DELETE /repos/{owner}/{repo}/issues/{index}/comments/{id} is deprecated.", DeprecationWarning)

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_delete_comment_deprecated" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # authentication setting
        _auth_settings = ['TOTPHeader', 'AuthorizationHeaderToken', 'SudoHeader', 'BasicAuth', 'AccessToken', 'SudoParam', 'Token']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/comments/{id}', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_delete_comment_reaction(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], content : Optional[EditReactionOption] = None, **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_delete_comment_reaction(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], content : Optional[EditReactionOption] = None, async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_delete_comment_reaction(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], content : Optional[EditReactionOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Remove a reaction from a comment of an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_comment_reaction(owner, repo, id, content, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment to edit (required)
        :type id: int
        :param content:
        :type content: EditReactionOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_delete_comment_reaction_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_delete_comment_reaction_with_http_info(owner, repo, id, content, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_delete_comment_reaction_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], content : Optional[EditReactionOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Remove a reaction from a comment of an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_comment_reaction_with_http_info(owner, repo, id, content, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment to edit (required)
        :type id: int
        :param content:
        :type content: EditReactionOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id',
            'content'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_delete_comment_reaction" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['content'] is not None:
            _body_params = _params['content']

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/comments/{id}/reactions', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_delete_issue_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to delete")], **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_delete_issue_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to delete")], async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_delete_issue_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to delete")], async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Delete an issue attachment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_issue_attachment(owner, repo, index, attachment_id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param attachment_id: id of the attachment to delete (required)
        :type attachment_id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_delete_issue_attachment_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_delete_issue_attachment_with_http_info(owner, repo, index, attachment_id, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_delete_issue_attachment_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to delete")], **kwargs) -> ApiResponse:  # noqa: E501
        """Delete an issue attachment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_issue_attachment_with_http_info(owner, repo, index, attachment_id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param attachment_id: id of the attachment to delete (required)
        :type attachment_id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'attachment_id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_delete_issue_attachment" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']

        if _params['attachment_id']:
            _path_params['attachment_id'] = _params['attachment_id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # authentication setting
        _auth_settings = ['TOTPHeader', 'AuthorizationHeaderToken', 'SudoHeader', 'BasicAuth', 'AccessToken', 'SudoParam', 'Token']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/assets/{attachment_id}', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_delete_issue_comment_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to delete")], **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_delete_issue_comment_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to delete")], async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_delete_issue_comment_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to delete")], async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Delete a comment attachment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_issue_comment_attachment(owner, repo, id, attachment_id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment (required)
        :type id: int
        :param attachment_id: id of the attachment to delete (required)
        :type attachment_id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_delete_issue_comment_attachment_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_delete_issue_comment_attachment_with_http_info(owner, repo, id, attachment_id, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_delete_issue_comment_attachment_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to delete")], **kwargs) -> ApiResponse:  # noqa: E501
        """Delete a comment attachment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_issue_comment_attachment_with_http_info(owner, repo, id, attachment_id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment (required)
        :type id: int
        :param attachment_id: id of the attachment to delete (required)
        :type attachment_id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id',
            'attachment_id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_delete_issue_comment_attachment" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']

        if _params['attachment_id']:
            _path_params['attachment_id'] = _params['attachment_id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # authentication setting
        _auth_settings = ['TOTPHeader', 'AuthorizationHeaderToken', 'SudoHeader', 'BasicAuth', 'AccessToken', 'SudoParam', 'Token']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/comments/{id}/assets/{attachment_id}', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_delete_issue_reaction(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], content : Optional[EditReactionOption] = None, **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_delete_issue_reaction(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], content : Optional[EditReactionOption] = None, async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_delete_issue_reaction(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], content : Optional[EditReactionOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Remove a reaction from an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_issue_reaction(owner, repo, index, content, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param content:
        :type content: EditReactionOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_delete_issue_reaction_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_delete_issue_reaction_with_http_info(owner, repo, index, content, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_delete_issue_reaction_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], content : Optional[EditReactionOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Remove a reaction from an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_issue_reaction_with_http_info(owner, repo, index, content, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param content:
        :type content: EditReactionOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'content'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_delete_issue_reaction" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['content'] is not None:
            _body_params = _params['content']

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/reactions', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_delete_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the label to delete")], **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_delete_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the label to delete")], async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_delete_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the label to delete")], async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Delete a label  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_label(owner, repo, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the label to delete (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_delete_label_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_delete_label_with_http_info(owner, repo, id, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_delete_label_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the label to delete")], **kwargs) -> ApiResponse:  # noqa: E501
        """Delete a label  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_label_with_http_info(owner, repo, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the label to delete (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_delete_label" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # authentication setting
        _auth_settings = ['TOTPHeader', 'AuthorizationHeaderToken', 'SudoHeader', 'BasicAuth', 'AccessToken', 'SudoParam', 'Token']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/labels/{id}', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_delete_milestone(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictStr, Field(..., description="the milestone to delete, identified by ID and if not available by name")], **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_delete_milestone(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictStr, Field(..., description="the milestone to delete, identified by ID and if not available by name")], async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_delete_milestone(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictStr, Field(..., description="the milestone to delete, identified by ID and if not available by name")], async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Delete a milestone  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_milestone(owner, repo, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: the milestone to delete, identified by ID and if not available by name (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_delete_milestone_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_delete_milestone_with_http_info(owner, repo, id, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_delete_milestone_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictStr, Field(..., description="the milestone to delete, identified by ID and if not available by name")], **kwargs) -> ApiResponse:  # noqa: E501
        """Delete a milestone  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_milestone_with_http_info(owner, repo, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: the milestone to delete, identified by ID and if not available by name (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_delete_milestone" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # authentication setting
        _auth_settings = ['TOTPHeader', 'AuthorizationHeaderToken', 'SudoHeader', 'BasicAuth', 'AccessToken', 'SudoParam', 'Token']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/milestones/{id}', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_delete_stop_watch(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to stop the stopwatch on")], **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_delete_stop_watch(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to stop the stopwatch on")], async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_delete_stop_watch(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to stop the stopwatch on")], async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Delete an issue's existing stopwatch.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_stop_watch(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue to stop the stopwatch on (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_delete_stop_watch_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_delete_stop_watch_with_http_info(owner, repo, index, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_delete_stop_watch_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to stop the stopwatch on")], **kwargs) -> ApiResponse:  # noqa: E501
        """Delete an issue's existing stopwatch.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_stop_watch_with_http_info(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue to stop the stopwatch on (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_delete_stop_watch" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # authentication setting
        _auth_settings = ['TOTPHeader', 'AuthorizationHeaderToken', 'SudoHeader', 'BasicAuth', 'AccessToken', 'SudoParam', 'Token']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/stopwatch/delete', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_delete_subscription(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], user : Annotated[StrictStr, Field(..., description="user witch unsubscribe")], **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_delete_subscription(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], user : Annotated[StrictStr, Field(..., description="user witch unsubscribe")], async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_delete_subscription(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], user : Annotated[StrictStr, Field(..., description="user witch unsubscribe")], async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Unsubscribe user from issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_subscription(owner, repo, index, user, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param user: user witch unsubscribe (required)
        :type user: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_delete_subscription_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_delete_subscription_with_http_info(owner, repo, index, user, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_delete_subscription_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], user : Annotated[StrictStr, Field(..., description="user witch unsubscribe")], **kwargs) -> ApiResponse:  # noqa: E501
        """Unsubscribe user from issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_subscription_with_http_info(owner, repo, index, user, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param user: user witch unsubscribe (required)
        :type user: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'user'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_delete_subscription" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']

        if _params['user']:
            _path_params['user'] = _params['user']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # authentication setting
        _auth_settings = ['TOTPHeader', 'AuthorizationHeaderToken', 'SudoHeader', 'BasicAuth', 'AccessToken', 'SudoParam', 'Token']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/subscriptions/{user}', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_delete_time(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], id : Annotated[StrictInt, Field(..., description="id of time to delete")], **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_delete_time(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], id : Annotated[StrictInt, Field(..., description="id of time to delete")], async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_delete_time(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], id : Annotated[StrictInt, Field(..., description="id of time to delete")], async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Delete specific tracked time  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_time(owner, repo, index, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param id: id of time to delete (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_delete_time_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_delete_time_with_http_info(owner, repo, index, id, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_delete_time_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], id : Annotated[StrictInt, Field(..., description="id of time to delete")], **kwargs) -> ApiResponse:  # noqa: E501
        """Delete specific tracked time  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_delete_time_with_http_info(owner, repo, index, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param id: id of time to delete (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_delete_time" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # authentication setting
        _auth_settings = ['TOTPHeader', 'AuthorizationHeaderToken', 'SudoHeader', 'BasicAuth', 'AccessToken', 'SudoParam', 'Token']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/times/{id}', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_edit_comment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], body : Optional[EditIssueCommentOption] = None, **kwargs) -> Comment:  # noqa: E501
        ...

    @overload
    def issue_edit_comment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], body : Optional[EditIssueCommentOption] = None, async_req: Optional[bool]=True, **kwargs) -> Comment:  # noqa: E501
        ...

    @validate_arguments
    def issue_edit_comment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], body : Optional[EditIssueCommentOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Comment, Awaitable[Comment]]:  # noqa: E501
        """Edit a comment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_edit_comment(owner, repo, id, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment to edit (required)
        :type id: int
        :param body:
        :type body: EditIssueCommentOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Comment
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_edit_comment_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_edit_comment_with_http_info(owner, repo, id, body, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_edit_comment_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], body : Optional[EditIssueCommentOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Edit a comment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_edit_comment_with_http_info(owner, repo, id, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment to edit (required)
        :type id: int
        :param body:
        :type body: EditIssueCommentOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Comment, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id',
            'body'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_edit_comment" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['body'] is not None:
            _body_params = _params['body']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '200': "Comment",
            '204': None,
            '403': None,
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/comments/{id}', 'PATCH',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_edit_comment_deprecated(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="this parameter is ignored")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], body : Optional[EditIssueCommentOption] = None, **kwargs) -> Comment:  # noqa: E501
        ...

    @overload
    def issue_edit_comment_deprecated(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="this parameter is ignored")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], body : Optional[EditIssueCommentOption] = None, async_req: Optional[bool]=True, **kwargs) -> Comment:  # noqa: E501
        ...

    @validate_arguments
    def issue_edit_comment_deprecated(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="this parameter is ignored")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], body : Optional[EditIssueCommentOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Comment, Awaitable[Comment]]:  # noqa: E501
        """(Deprecated) Edit a comment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_edit_comment_deprecated(owner, repo, index, id, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: this parameter is ignored (required)
        :type index: int
        :param id: id of the comment to edit (required)
        :type id: int
        :param body:
        :type body: EditIssueCommentOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Comment
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_edit_comment_deprecated_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_edit_comment_deprecated_with_http_info(owner, repo, index, id, body, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_edit_comment_deprecated_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="this parameter is ignored")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], body : Optional[EditIssueCommentOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """(Deprecated) Edit a comment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_edit_comment_deprecated_with_http_info(owner, repo, index, id, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: this parameter is ignored (required)
        :type index: int
        :param id: id of the comment to edit (required)
        :type id: int
        :param body:
        :type body: EditIssueCommentOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Comment, status_code(int), headers(HTTPHeaderDict))
        """

        warnings.warn("PATCH /repos/{owner}/{repo}/issues/{index}/comments/{id} is deprecated.", DeprecationWarning)

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'id',
            'body'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_edit_comment_deprecated" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['body'] is not None:
            _body_params = _params['body']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '200': "Comment",
            '204': None,
            '403': None,
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/comments/{id}', 'PATCH',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_edit_issue(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to edit")], body : Optional[EditIssueOption] = None, **kwargs) -> Issue:  # noqa: E501
        ...

    @overload
    def issue_edit_issue(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to edit")], body : Optional[EditIssueOption] = None, async_req: Optional[bool]=True, **kwargs) -> Issue:  # noqa: E501
        ...

    @validate_arguments
    def issue_edit_issue(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to edit")], body : Optional[EditIssueOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Issue, Awaitable[Issue]]:  # noqa: E501
        """Edit an issue. If using deadline only the date will be taken into account, and time of day ignored.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_edit_issue(owner, repo, index, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue to edit (required)
        :type index: int
        :param body:
        :type body: EditIssueOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Issue
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_edit_issue_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_edit_issue_with_http_info(owner, repo, index, body, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_edit_issue_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to edit")], body : Optional[EditIssueOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Edit an issue. If using deadline only the date will be taken into account, and time of day ignored.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_edit_issue_with_http_info(owner, repo, index, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue to edit (required)
        :type index: int
        :param body:
        :type body: EditIssueOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Issue, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'body'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_edit_issue" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['body'] is not None:
            _body_params = _params['body']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '201': "Issue",
            '403': None,
            '404': None,
            '412': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}', 'PATCH',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_edit_issue_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to edit")], body : Optional[EditAttachmentOptions] = None, **kwargs) -> Attachment:  # noqa: E501
        ...

    @overload
    def issue_edit_issue_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to edit")], body : Optional[EditAttachmentOptions] = None, async_req: Optional[bool]=True, **kwargs) -> Attachment:  # noqa: E501
        ...

    @validate_arguments
    def issue_edit_issue_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to edit")], body : Optional[EditAttachmentOptions] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Attachment, Awaitable[Attachment]]:  # noqa: E501
        """Edit an issue attachment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_edit_issue_attachment(owner, repo, index, attachment_id, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param attachment_id: id of the attachment to edit (required)
        :type attachment_id: int
        :param body:
        :type body: EditAttachmentOptions
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Attachment
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_edit_issue_attachment_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_edit_issue_attachment_with_http_info(owner, repo, index, attachment_id, body, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_edit_issue_attachment_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to edit")], body : Optional[EditAttachmentOptions] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Edit an issue attachment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_edit_issue_attachment_with_http_info(owner, repo, index, attachment_id, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param attachment_id: id of the attachment to edit (required)
        :type attachment_id: int
        :param body:
        :type body: EditAttachmentOptions
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Attachment, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'attachment_id',
            'body'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_edit_issue_attachment" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']

        if _params['attachment_id']:
            _path_params['attachment_id'] = _params['attachment_id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['body'] is not None:
            _body_params = _params['body']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '201': "Attachment",
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/assets/{attachment_id}', 'PATCH',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_edit_issue_comment_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to edit")], body : Optional[EditAttachmentOptions] = None, **kwargs) -> Attachment:  # noqa: E501
        ...

    @overload
    def issue_edit_issue_comment_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to edit")], body : Optional[EditAttachmentOptions] = None, async_req: Optional[bool]=True, **kwargs) -> Attachment:  # noqa: E501
        ...

    @validate_arguments
    def issue_edit_issue_comment_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to edit")], body : Optional[EditAttachmentOptions] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Attachment, Awaitable[Attachment]]:  # noqa: E501
        """Edit a comment attachment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_edit_issue_comment_attachment(owner, repo, id, attachment_id, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment (required)
        :type id: int
        :param attachment_id: id of the attachment to edit (required)
        :type attachment_id: int
        :param body:
        :type body: EditAttachmentOptions
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Attachment
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_edit_issue_comment_attachment_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_edit_issue_comment_attachment_with_http_info(owner, repo, id, attachment_id, body, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_edit_issue_comment_attachment_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to edit")], body : Optional[EditAttachmentOptions] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Edit a comment attachment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_edit_issue_comment_attachment_with_http_info(owner, repo, id, attachment_id, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment (required)
        :type id: int
        :param attachment_id: id of the attachment to edit (required)
        :type attachment_id: int
        :param body:
        :type body: EditAttachmentOptions
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Attachment, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id',
            'attachment_id',
            'body'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_edit_issue_comment_attachment" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']

        if _params['attachment_id']:
            _path_params['attachment_id'] = _params['attachment_id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['body'] is not None:
            _body_params = _params['body']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '201': "Attachment",
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/comments/{id}/assets/{attachment_id}', 'PATCH',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_edit_issue_deadline(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to create or update a deadline on")], body : Optional[EditDeadlineOption] = None, **kwargs) -> IssueDeadline:  # noqa: E501
        ...

    @overload
    def issue_edit_issue_deadline(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to create or update a deadline on")], body : Optional[EditDeadlineOption] = None, async_req: Optional[bool]=True, **kwargs) -> IssueDeadline:  # noqa: E501
        ...

    @validate_arguments
    def issue_edit_issue_deadline(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to create or update a deadline on")], body : Optional[EditDeadlineOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[IssueDeadline, Awaitable[IssueDeadline]]:  # noqa: E501
        """Set an issue deadline. If set to null, the deadline is deleted. If using deadline only the date will be taken into account, and time of day ignored.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_edit_issue_deadline(owner, repo, index, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue to create or update a deadline on (required)
        :type index: int
        :param body:
        :type body: EditDeadlineOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: IssueDeadline
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_edit_issue_deadline_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_edit_issue_deadline_with_http_info(owner, repo, index, body, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_edit_issue_deadline_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to create or update a deadline on")], body : Optional[EditDeadlineOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Set an issue deadline. If set to null, the deadline is deleted. If using deadline only the date will be taken into account, and time of day ignored.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_edit_issue_deadline_with_http_info(owner, repo, index, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue to create or update a deadline on (required)
        :type index: int
        :param body:
        :type body: EditDeadlineOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(IssueDeadline, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'body'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_edit_issue_deadline" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['body'] is not None:
            _body_params = _params['body']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '201': "IssueDeadline",
            '403': None,
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/deadline', 'POST',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_edit_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the label to edit")], body : Optional[EditLabelOption] = None, **kwargs) -> Label:  # noqa: E501
        ...

    @overload
    def issue_edit_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the label to edit")], body : Optional[EditLabelOption] = None, async_req: Optional[bool]=True, **kwargs) -> Label:  # noqa: E501
        ...

    @validate_arguments
    def issue_edit_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the label to edit")], body : Optional[EditLabelOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Label, Awaitable[Label]]:  # noqa: E501
        """Update a label  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_edit_label(owner, repo, id, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the label to edit (required)
        :type id: int
        :param body:
        :type body: EditLabelOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Label
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_edit_label_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_edit_label_with_http_info(owner, repo, id, body, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_edit_label_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the label to edit")], body : Optional[EditLabelOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Update a label  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_edit_label_with_http_info(owner, repo, id, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the label to edit (required)
        :type id: int
        :param body:
        :type body: EditLabelOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Label, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id',
            'body'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_edit_label" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['body'] is not None:
            _body_params = _params['body']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '200': "Label",
            '422': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/labels/{id}', 'PATCH',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_edit_milestone(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictStr, Field(..., description="the milestone to edit, identified by ID and if not available by name")], body : Optional[EditMilestoneOption] = None, **kwargs) -> Milestone:  # noqa: E501
        ...

    @overload
    def issue_edit_milestone(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictStr, Field(..., description="the milestone to edit, identified by ID and if not available by name")], body : Optional[EditMilestoneOption] = None, async_req: Optional[bool]=True, **kwargs) -> Milestone:  # noqa: E501
        ...

    @validate_arguments
    def issue_edit_milestone(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictStr, Field(..., description="the milestone to edit, identified by ID and if not available by name")], body : Optional[EditMilestoneOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Milestone, Awaitable[Milestone]]:  # noqa: E501
        """Update a milestone  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_edit_milestone(owner, repo, id, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: the milestone to edit, identified by ID and if not available by name (required)
        :type id: str
        :param body:
        :type body: EditMilestoneOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Milestone
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_edit_milestone_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_edit_milestone_with_http_info(owner, repo, id, body, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_edit_milestone_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictStr, Field(..., description="the milestone to edit, identified by ID and if not available by name")], body : Optional[EditMilestoneOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Update a milestone  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_edit_milestone_with_http_info(owner, repo, id, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: the milestone to edit, identified by ID and if not available by name (required)
        :type id: str
        :param body:
        :type body: EditMilestoneOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Milestone, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id',
            'body'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_edit_milestone" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['body'] is not None:
            _body_params = _params['body']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '200': "Milestone",
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/milestones/{id}', 'PATCH',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_get_comment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], **kwargs) -> Comment:  # noqa: E501
        ...

    @overload
    def issue_get_comment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], async_req: Optional[bool]=True, **kwargs) -> Comment:  # noqa: E501
        ...

    @validate_arguments
    def issue_get_comment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], async_req: Optional[bool]=None, **kwargs) -> Union[Comment, Awaitable[Comment]]:  # noqa: E501
        """Get a comment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_comment(owner, repo, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Comment
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_get_comment_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_get_comment_with_http_info(owner, repo, id, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_get_comment_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get a comment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_comment_with_http_info(owner, repo, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Comment, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_get_comment" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "Comment",
            '204': None,
            '403': None,
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/comments/{id}', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_get_comment_reactions(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], **kwargs) -> List[Reaction]:  # noqa: E501
        ...

    @overload
    def issue_get_comment_reactions(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], async_req: Optional[bool]=True, **kwargs) -> List[Reaction]:  # noqa: E501
        ...

    @validate_arguments
    def issue_get_comment_reactions(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], async_req: Optional[bool]=None, **kwargs) -> Union[List[Reaction], Awaitable[List[Reaction]]]:  # noqa: E501
        """Get a list of reactions from a comment of an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_comment_reactions(owner, repo, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment to edit (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[Reaction]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_get_comment_reactions_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_get_comment_reactions_with_http_info(owner, repo, id, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_get_comment_reactions_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get a list of reactions from a comment of an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_comment_reactions_with_http_info(owner, repo, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment to edit (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[Reaction], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_get_comment_reactions" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "List[Reaction]",
            '403': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/comments/{id}/reactions', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_get_comments(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], since : Annotated[Optional[datetime], Field(description="if provided, only comments updated since the specified time are returned.")] = None, before : Annotated[Optional[datetime], Field(description="if provided, only comments updated before the provided time are returned.")] = None, **kwargs) -> List[Comment]:  # noqa: E501
        ...

    @overload
    def issue_get_comments(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], since : Annotated[Optional[datetime], Field(description="if provided, only comments updated since the specified time are returned.")] = None, before : Annotated[Optional[datetime], Field(description="if provided, only comments updated before the provided time are returned.")] = None, async_req: Optional[bool]=True, **kwargs) -> List[Comment]:  # noqa: E501
        ...

    @validate_arguments
    def issue_get_comments(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], since : Annotated[Optional[datetime], Field(description="if provided, only comments updated since the specified time are returned.")] = None, before : Annotated[Optional[datetime], Field(description="if provided, only comments updated before the provided time are returned.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[List[Comment], Awaitable[List[Comment]]]:  # noqa: E501
        """List all comments on an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_comments(owner, repo, index, since, before, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param since: if provided, only comments updated since the specified time are returned.
        :type since: datetime
        :param before: if provided, only comments updated before the provided time are returned.
        :type before: datetime
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[Comment]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_get_comments_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_get_comments_with_http_info(owner, repo, index, since, before, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_get_comments_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], since : Annotated[Optional[datetime], Field(description="if provided, only comments updated since the specified time are returned.")] = None, before : Annotated[Optional[datetime], Field(description="if provided, only comments updated before the provided time are returned.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """List all comments on an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_comments_with_http_info(owner, repo, index, since, before, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param since: if provided, only comments updated since the specified time are returned.
        :type since: datetime
        :param before: if provided, only comments updated before the provided time are returned.
        :type before: datetime
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[Comment], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'since',
            'before'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_get_comments" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        if _params.get('since') is not None:  # noqa: E501
            if isinstance(_params['since'], datetime):
                _query_params.append(('since', _params['since'].strftime(self.api_client.configuration.datetime_format)))
            else:
                _query_params.append(('since', _params['since']))

        if _params.get('before') is not None:  # noqa: E501
            if isinstance(_params['before'], datetime):
                _query_params.append(('before', _params['before'].strftime(self.api_client.configuration.datetime_format)))
            else:
                _query_params.append(('before', _params['before']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "List[Comment]",
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/comments', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_get_comments_and_timeline(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], since : Annotated[Optional[datetime], Field(description="if provided, only comments updated since the specified time are returned.")] = 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, before : Annotated[Optional[datetime], Field(description="if provided, only comments updated before the provided time are returned.")] = None, **kwargs) -> List[TimelineComment]:  # noqa: E501
        ...

    @overload
    def issue_get_comments_and_timeline(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], since : Annotated[Optional[datetime], Field(description="if provided, only comments updated since the specified time are returned.")] = 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, before : Annotated[Optional[datetime], Field(description="if provided, only comments updated before the provided time are returned.")] = None, async_req: Optional[bool]=True, **kwargs) -> List[TimelineComment]:  # noqa: E501
        ...

    @validate_arguments
    def issue_get_comments_and_timeline(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], since : Annotated[Optional[datetime], Field(description="if provided, only comments updated since the specified time are returned.")] = 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, before : Annotated[Optional[datetime], Field(description="if provided, only comments updated before the provided time are returned.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[List[TimelineComment], Awaitable[List[TimelineComment]]]:  # noqa: E501
        """List all comments and events on an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_comments_and_timeline(owner, repo, index, since, page, limit, before, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param since: if provided, only comments updated since the specified time are returned.
        :type since: datetime
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param before: if provided, only comments updated before the provided time are returned.
        :type before: datetime
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[TimelineComment]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_get_comments_and_timeline_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_get_comments_and_timeline_with_http_info(owner, repo, index, since, page, limit, before, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_get_comments_and_timeline_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], since : Annotated[Optional[datetime], Field(description="if provided, only comments updated since the specified time are returned.")] = 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, before : Annotated[Optional[datetime], Field(description="if provided, only comments updated before the provided time are returned.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """List all comments and events on an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_comments_and_timeline_with_http_info(owner, repo, index, since, page, limit, before, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param since: if provided, only comments updated since the specified time are returned.
        :type since: datetime
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param before: if provided, only comments updated before the provided time are returned.
        :type before: datetime
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[TimelineComment], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'since',
            'page',
            'limit',
            'before'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_get_comments_and_timeline" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        if _params.get('since') is not None:  # noqa: E501
            if isinstance(_params['since'], datetime):
                _query_params.append(('since', _params['since'].strftime(self.api_client.configuration.datetime_format)))
            else:
                _query_params.append(('since', _params['since']))

        if _params.get('page') is not None:  # noqa: E501
            _query_params.append(('page', _params['page']))

        if _params.get('limit') is not None:  # noqa: E501
            _query_params.append(('limit', _params['limit']))

        if _params.get('before') is not None:  # noqa: E501
            if isinstance(_params['before'], datetime):
                _query_params.append(('before', _params['before'].strftime(self.api_client.configuration.datetime_format)))
            else:
                _query_params.append(('before', _params['before']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "List[TimelineComment]",
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/timeline', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_get_issue(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to get")], **kwargs) -> Issue:  # noqa: E501
        ...

    @overload
    def issue_get_issue(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to get")], async_req: Optional[bool]=True, **kwargs) -> Issue:  # noqa: E501
        ...

    @validate_arguments
    def issue_get_issue(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to get")], async_req: Optional[bool]=None, **kwargs) -> Union[Issue, Awaitable[Issue]]:  # noqa: E501
        """Get an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_issue(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue to get (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Issue
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_get_issue_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_get_issue_with_http_info(owner, repo, index, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_get_issue_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to get")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_issue_with_http_info(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue to get (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Issue, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_get_issue" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "Issue",
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_get_issue_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to get")], **kwargs) -> Attachment:  # noqa: E501
        ...

    @overload
    def issue_get_issue_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to get")], async_req: Optional[bool]=True, **kwargs) -> Attachment:  # noqa: E501
        ...

    @validate_arguments
    def issue_get_issue_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to get")], async_req: Optional[bool]=None, **kwargs) -> Union[Attachment, Awaitable[Attachment]]:  # noqa: E501
        """Get an issue attachment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_issue_attachment(owner, repo, index, attachment_id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param attachment_id: id of the attachment to get (required)
        :type attachment_id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Attachment
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_get_issue_attachment_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_get_issue_attachment_with_http_info(owner, repo, index, attachment_id, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_get_issue_attachment_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to get")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get an issue attachment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_issue_attachment_with_http_info(owner, repo, index, attachment_id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param attachment_id: id of the attachment to get (required)
        :type attachment_id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Attachment, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'attachment_id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_get_issue_attachment" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']

        if _params['attachment_id']:
            _path_params['attachment_id'] = _params['attachment_id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "Attachment",
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/assets/{attachment_id}', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_get_issue_comment_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to get")], **kwargs) -> Attachment:  # noqa: E501
        ...

    @overload
    def issue_get_issue_comment_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to get")], async_req: Optional[bool]=True, **kwargs) -> Attachment:  # noqa: E501
        ...

    @validate_arguments
    def issue_get_issue_comment_attachment(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to get")], async_req: Optional[bool]=None, **kwargs) -> Union[Attachment, Awaitable[Attachment]]:  # noqa: E501
        """Get a comment attachment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_issue_comment_attachment(owner, repo, id, attachment_id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment (required)
        :type id: int
        :param attachment_id: id of the attachment to get (required)
        :type attachment_id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Attachment
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_get_issue_comment_attachment_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_get_issue_comment_attachment_with_http_info(owner, repo, id, attachment_id, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_get_issue_comment_attachment_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], attachment_id : Annotated[StrictInt, Field(..., description="id of the attachment to get")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get a comment attachment  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_issue_comment_attachment_with_http_info(owner, repo, id, attachment_id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment (required)
        :type id: int
        :param attachment_id: id of the attachment to get (required)
        :type attachment_id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Attachment, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id',
            'attachment_id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_get_issue_comment_attachment" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']

        if _params['attachment_id']:
            _path_params['attachment_id'] = _params['attachment_id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "Attachment",
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/comments/{id}/assets/{attachment_id}', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_get_issue_reactions(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], 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, **kwargs) -> List[Reaction]:  # noqa: E501
        ...

    @overload
    def issue_get_issue_reactions(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], 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, async_req: Optional[bool]=True, **kwargs) -> List[Reaction]:  # noqa: E501
        ...

    @validate_arguments
    def issue_get_issue_reactions(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], 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, async_req: Optional[bool]=None, **kwargs) -> Union[List[Reaction], Awaitable[List[Reaction]]]:  # noqa: E501
        """Get a list reactions of an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_issue_reactions(owner, repo, index, page, limit, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[Reaction]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_get_issue_reactions_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_get_issue_reactions_with_http_info(owner, repo, index, page, limit, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_get_issue_reactions_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], 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, **kwargs) -> ApiResponse:  # noqa: E501
        """Get a list reactions of an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_issue_reactions_with_http_info(owner, repo, index, page, limit, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[Reaction], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'page',
            'limit'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_get_issue_reactions" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        if _params.get('page') is not None:  # noqa: E501
            _query_params.append(('page', _params['page']))

        if _params.get('limit') is not None:  # noqa: E501
            _query_params.append(('limit', _params['limit']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "List[Reaction]",
            '403': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/reactions', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_get_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the label to get")], **kwargs) -> Label:  # noqa: E501
        ...

    @overload
    def issue_get_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the label to get")], async_req: Optional[bool]=True, **kwargs) -> Label:  # noqa: E501
        ...

    @validate_arguments
    def issue_get_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the label to get")], async_req: Optional[bool]=None, **kwargs) -> Union[Label, Awaitable[Label]]:  # noqa: E501
        """Get a single label  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_label(owner, repo, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the label to get (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Label
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_get_label_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_get_label_with_http_info(owner, repo, id, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_get_label_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the label to get")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get a single label  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_label_with_http_info(owner, repo, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the label to get (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Label, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_get_label" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "Label",
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/labels/{id}', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_get_labels(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], **kwargs) -> List[Label]:  # noqa: E501
        ...

    @overload
    def issue_get_labels(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], async_req: Optional[bool]=True, **kwargs) -> List[Label]:  # noqa: E501
        ...

    @validate_arguments
    def issue_get_labels(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], async_req: Optional[bool]=None, **kwargs) -> Union[List[Label], Awaitable[List[Label]]]:  # noqa: E501
        """Get an issue's labels  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_labels(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[Label]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_get_labels_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_get_labels_with_http_info(owner, repo, index, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_get_labels_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get an issue's labels  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_labels_with_http_info(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[Label], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_get_labels" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "List[Label]",
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/labels', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_get_milestone(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictStr, Field(..., description="the milestone to get, identified by ID and if not available by name")], **kwargs) -> Milestone:  # noqa: E501
        ...

    @overload
    def issue_get_milestone(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictStr, Field(..., description="the milestone to get, identified by ID and if not available by name")], async_req: Optional[bool]=True, **kwargs) -> Milestone:  # noqa: E501
        ...

    @validate_arguments
    def issue_get_milestone(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictStr, Field(..., description="the milestone to get, identified by ID and if not available by name")], async_req: Optional[bool]=None, **kwargs) -> Union[Milestone, Awaitable[Milestone]]:  # noqa: E501
        """Get a milestone  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_milestone(owner, repo, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: the milestone to get, identified by ID and if not available by name (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Milestone
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_get_milestone_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_get_milestone_with_http_info(owner, repo, id, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_get_milestone_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictStr, Field(..., description="the milestone to get, identified by ID and if not available by name")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get a milestone  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_milestone_with_http_info(owner, repo, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: the milestone to get, identified by ID and if not available by name (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Milestone, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_get_milestone" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "Milestone",
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/milestones/{id}', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_get_milestones_list(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], state : Annotated[Optional[StrictStr], Field(description="Milestone state, Recognized values are open, closed and all. Defaults to \"open\"")] = None, name : Annotated[Optional[StrictStr], Field(description="filter by milestone name")] = 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, **kwargs) -> List[Milestone]:  # noqa: E501
        ...

    @overload
    def issue_get_milestones_list(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], state : Annotated[Optional[StrictStr], Field(description="Milestone state, Recognized values are open, closed and all. Defaults to \"open\"")] = None, name : Annotated[Optional[StrictStr], Field(description="filter by milestone name")] = 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, async_req: Optional[bool]=True, **kwargs) -> List[Milestone]:  # noqa: E501
        ...

    @validate_arguments
    def issue_get_milestones_list(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], state : Annotated[Optional[StrictStr], Field(description="Milestone state, Recognized values are open, closed and all. Defaults to \"open\"")] = None, name : Annotated[Optional[StrictStr], Field(description="filter by milestone name")] = 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, async_req: Optional[bool]=None, **kwargs) -> Union[List[Milestone], Awaitable[List[Milestone]]]:  # noqa: E501
        """Get all of a repository's opened milestones  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_milestones_list(owner, repo, state, name, page, limit, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param state: Milestone state, Recognized values are open, closed and all. Defaults to \"open\"
        :type state: str
        :param name: filter by milestone name
        :type name: str
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[Milestone]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_get_milestones_list_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_get_milestones_list_with_http_info(owner, repo, state, name, page, limit, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_get_milestones_list_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], state : Annotated[Optional[StrictStr], Field(description="Milestone state, Recognized values are open, closed and all. Defaults to \"open\"")] = None, name : Annotated[Optional[StrictStr], Field(description="filter by milestone name")] = 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, **kwargs) -> ApiResponse:  # noqa: E501
        """Get all of a repository's opened milestones  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_milestones_list_with_http_info(owner, repo, state, name, page, limit, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param state: Milestone state, Recognized values are open, closed and all. Defaults to \"open\"
        :type state: str
        :param name: filter by milestone name
        :type name: str
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[Milestone], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'state',
            'name',
            'page',
            'limit'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_get_milestones_list" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']


        # process the query parameters
        _query_params = []
        if _params.get('state') is not None:  # noqa: E501
            _query_params.append(('state', _params['state']))

        if _params.get('name') is not None:  # noqa: E501
            _query_params.append(('name', _params['name']))

        if _params.get('page') is not None:  # noqa: E501
            _query_params.append(('page', _params['page']))

        if _params.get('limit') is not None:  # noqa: E501
            _query_params.append(('limit', _params['limit']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "List[Milestone]",
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/milestones', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_get_repo_comments(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], since : Annotated[Optional[datetime], Field(description="if provided, only comments updated since the provided time are returned.")] = None, before : Annotated[Optional[datetime], Field(description="if provided, only comments updated before the provided time are returned.")] = 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, **kwargs) -> List[Comment]:  # noqa: E501
        ...

    @overload
    def issue_get_repo_comments(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], since : Annotated[Optional[datetime], Field(description="if provided, only comments updated since the provided time are returned.")] = None, before : Annotated[Optional[datetime], Field(description="if provided, only comments updated before the provided time are returned.")] = 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, async_req: Optional[bool]=True, **kwargs) -> List[Comment]:  # noqa: E501
        ...

    @validate_arguments
    def issue_get_repo_comments(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], since : Annotated[Optional[datetime], Field(description="if provided, only comments updated since the provided time are returned.")] = None, before : Annotated[Optional[datetime], Field(description="if provided, only comments updated before the provided time are returned.")] = 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, async_req: Optional[bool]=None, **kwargs) -> Union[List[Comment], Awaitable[List[Comment]]]:  # noqa: E501
        """List all comments in a repository  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_repo_comments(owner, repo, since, before, page, limit, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param since: if provided, only comments updated since the provided time are returned.
        :type since: datetime
        :param before: if provided, only comments updated before the provided time are returned.
        :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 async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[Comment]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_get_repo_comments_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_get_repo_comments_with_http_info(owner, repo, since, before, page, limit, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_get_repo_comments_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], since : Annotated[Optional[datetime], Field(description="if provided, only comments updated since the provided time are returned.")] = None, before : Annotated[Optional[datetime], Field(description="if provided, only comments updated before the provided time are returned.")] = 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, **kwargs) -> ApiResponse:  # noqa: E501
        """List all comments in a repository  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_get_repo_comments_with_http_info(owner, repo, since, before, page, limit, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param since: if provided, only comments updated since the provided time are returned.
        :type since: datetime
        :param before: if provided, only comments updated before the provided time are returned.
        :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 async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[Comment], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'since',
            'before',
            'page',
            'limit'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_get_repo_comments" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']


        # process the query parameters
        _query_params = []
        if _params.get('since') is not None:  # noqa: E501
            if isinstance(_params['since'], datetime):
                _query_params.append(('since', _params['since'].strftime(self.api_client.configuration.datetime_format)))
            else:
                _query_params.append(('since', _params['since']))

        if _params.get('before') is not None:  # noqa: E501
            if isinstance(_params['before'], datetime):
                _query_params.append(('before', _params['before'].strftime(self.api_client.configuration.datetime_format)))
            else:
                _query_params.append(('before', _params['before']))

        if _params.get('page') is not None:  # noqa: E501
            _query_params.append(('page', _params['page']))

        if _params.get('limit') is not None:  # noqa: E501
            _query_params.append(('limit', _params['limit']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "List[Comment]",
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/comments', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_list_issue_attachments(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], **kwargs) -> List[Attachment]:  # noqa: E501
        ...

    @overload
    def issue_list_issue_attachments(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], async_req: Optional[bool]=True, **kwargs) -> List[Attachment]:  # noqa: E501
        ...

    @validate_arguments
    def issue_list_issue_attachments(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], async_req: Optional[bool]=None, **kwargs) -> Union[List[Attachment], Awaitable[List[Attachment]]]:  # noqa: E501
        """List issue's attachments  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_list_issue_attachments(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[Attachment]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_list_issue_attachments_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_list_issue_attachments_with_http_info(owner, repo, index, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_list_issue_attachments_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], **kwargs) -> ApiResponse:  # noqa: E501
        """List issue's attachments  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_list_issue_attachments_with_http_info(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[Attachment], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_list_issue_attachments" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "List[Attachment]",
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/assets', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_list_issue_comment_attachments(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], **kwargs) -> List[Attachment]:  # noqa: E501
        ...

    @overload
    def issue_list_issue_comment_attachments(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], async_req: Optional[bool]=True, **kwargs) -> List[Attachment]:  # noqa: E501
        ...

    @validate_arguments
    def issue_list_issue_comment_attachments(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], async_req: Optional[bool]=None, **kwargs) -> Union[List[Attachment], Awaitable[List[Attachment]]]:  # noqa: E501
        """List comment's attachments  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_list_issue_comment_attachments(owner, repo, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[Attachment]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_list_issue_comment_attachments_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_list_issue_comment_attachments_with_http_info(owner, repo, id, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_list_issue_comment_attachments_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment")], **kwargs) -> ApiResponse:  # noqa: E501
        """List comment's attachments  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_list_issue_comment_attachments_with_http_info(owner, repo, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[Attachment], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_list_issue_comment_attachments" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "List[Attachment]",
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/comments/{id}/assets', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_list_issues(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], state : Annotated[Optional[StrictStr], Field(description="whether issue is open or closed")] = None, labels : Annotated[Optional[StrictStr], Field(description="comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded")] = None, q : Annotated[Optional[StrictStr], Field(description="search string")] = None, type : Annotated[Optional[StrictStr], Field(description="filter by type (issues / pulls) if set")] = None, milestones : Annotated[Optional[StrictStr], Field(description="comma separated list of milestone names or ids. It uses names and fall back to ids. Fetch only issues that have any of this milestones. Non existent milestones are discarded")] = None, since : Annotated[Optional[datetime], Field(description="Only show items updated after the given time. This is a timestamp in RFC 3339 format")] = None, before : Annotated[Optional[datetime], Field(description="Only show items updated before the given time. This is a timestamp in RFC 3339 format")] = None, created_by : Annotated[Optional[StrictStr], Field(description="Only show items which were created by the the given user")] = None, assigned_by : Annotated[Optional[StrictStr], Field(description="Only show items for which the given user is assigned")] = None, mentioned_by : Annotated[Optional[StrictStr], Field(description="Only show items in which the given user was mentioned")] = 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, **kwargs) -> List[Issue]:  # noqa: E501
        ...

    @overload
    def issue_list_issues(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], state : Annotated[Optional[StrictStr], Field(description="whether issue is open or closed")] = None, labels : Annotated[Optional[StrictStr], Field(description="comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded")] = None, q : Annotated[Optional[StrictStr], Field(description="search string")] = None, type : Annotated[Optional[StrictStr], Field(description="filter by type (issues / pulls) if set")] = None, milestones : Annotated[Optional[StrictStr], Field(description="comma separated list of milestone names or ids. It uses names and fall back to ids. Fetch only issues that have any of this milestones. Non existent milestones are discarded")] = None, since : Annotated[Optional[datetime], Field(description="Only show items updated after the given time. This is a timestamp in RFC 3339 format")] = None, before : Annotated[Optional[datetime], Field(description="Only show items updated before the given time. This is a timestamp in RFC 3339 format")] = None, created_by : Annotated[Optional[StrictStr], Field(description="Only show items which were created by the the given user")] = None, assigned_by : Annotated[Optional[StrictStr], Field(description="Only show items for which the given user is assigned")] = None, mentioned_by : Annotated[Optional[StrictStr], Field(description="Only show items in which the given user was mentioned")] = 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, async_req: Optional[bool]=True, **kwargs) -> List[Issue]:  # noqa: E501
        ...

    @validate_arguments
    def issue_list_issues(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], state : Annotated[Optional[StrictStr], Field(description="whether issue is open or closed")] = None, labels : Annotated[Optional[StrictStr], Field(description="comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded")] = None, q : Annotated[Optional[StrictStr], Field(description="search string")] = None, type : Annotated[Optional[StrictStr], Field(description="filter by type (issues / pulls) if set")] = None, milestones : Annotated[Optional[StrictStr], Field(description="comma separated list of milestone names or ids. It uses names and fall back to ids. Fetch only issues that have any of this milestones. Non existent milestones are discarded")] = None, since : Annotated[Optional[datetime], Field(description="Only show items updated after the given time. This is a timestamp in RFC 3339 format")] = None, before : Annotated[Optional[datetime], Field(description="Only show items updated before the given time. This is a timestamp in RFC 3339 format")] = None, created_by : Annotated[Optional[StrictStr], Field(description="Only show items which were created by the the given user")] = None, assigned_by : Annotated[Optional[StrictStr], Field(description="Only show items for which the given user is assigned")] = None, mentioned_by : Annotated[Optional[StrictStr], Field(description="Only show items in which the given user was mentioned")] = 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, async_req: Optional[bool]=None, **kwargs) -> Union[List[Issue], Awaitable[List[Issue]]]:  # noqa: E501
        """List a repository's issues  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_list_issues(owner, repo, state, labels, q, type, milestones, since, before, created_by, assigned_by, mentioned_by, page, limit, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param state: whether issue is open or closed
        :type state: str
        :param labels: comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded
        :type labels: str
        :param q: search string
        :type q: str
        :param type: filter by type (issues / pulls) if set
        :type type: str
        :param milestones: comma separated list of milestone names or ids. It uses names and fall back to ids. Fetch only issues that have any of this milestones. Non existent milestones are discarded
        :type milestones: str
        :param since: Only show items updated after the given time. This is a timestamp in RFC 3339 format
        :type since: datetime
        :param before: Only show items updated before the given time. This is a timestamp in RFC 3339 format
        :type before: datetime
        :param created_by: Only show items which were created by the the given user
        :type created_by: str
        :param assigned_by: Only show items for which the given user is assigned
        :type assigned_by: str
        :param mentioned_by: Only show items in which the given user was mentioned
        :type mentioned_by: str
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[Issue]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_list_issues_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_list_issues_with_http_info(owner, repo, state, labels, q, type, milestones, since, before, created_by, assigned_by, mentioned_by, page, limit, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_list_issues_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], state : Annotated[Optional[StrictStr], Field(description="whether issue is open or closed")] = None, labels : Annotated[Optional[StrictStr], Field(description="comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded")] = None, q : Annotated[Optional[StrictStr], Field(description="search string")] = None, type : Annotated[Optional[StrictStr], Field(description="filter by type (issues / pulls) if set")] = None, milestones : Annotated[Optional[StrictStr], Field(description="comma separated list of milestone names or ids. It uses names and fall back to ids. Fetch only issues that have any of this milestones. Non existent milestones are discarded")] = None, since : Annotated[Optional[datetime], Field(description="Only show items updated after the given time. This is a timestamp in RFC 3339 format")] = None, before : Annotated[Optional[datetime], Field(description="Only show items updated before the given time. This is a timestamp in RFC 3339 format")] = None, created_by : Annotated[Optional[StrictStr], Field(description="Only show items which were created by the the given user")] = None, assigned_by : Annotated[Optional[StrictStr], Field(description="Only show items for which the given user is assigned")] = None, mentioned_by : Annotated[Optional[StrictStr], Field(description="Only show items in which the given user was mentioned")] = 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, **kwargs) -> ApiResponse:  # noqa: E501
        """List a repository's issues  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_list_issues_with_http_info(owner, repo, state, labels, q, type, milestones, since, before, created_by, assigned_by, mentioned_by, page, limit, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param state: whether issue is open or closed
        :type state: str
        :param labels: comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded
        :type labels: str
        :param q: search string
        :type q: str
        :param type: filter by type (issues / pulls) if set
        :type type: str
        :param milestones: comma separated list of milestone names or ids. It uses names and fall back to ids. Fetch only issues that have any of this milestones. Non existent milestones are discarded
        :type milestones: str
        :param since: Only show items updated after the given time. This is a timestamp in RFC 3339 format
        :type since: datetime
        :param before: Only show items updated before the given time. This is a timestamp in RFC 3339 format
        :type before: datetime
        :param created_by: Only show items which were created by the the given user
        :type created_by: str
        :param assigned_by: Only show items for which the given user is assigned
        :type assigned_by: str
        :param mentioned_by: Only show items in which the given user was mentioned
        :type mentioned_by: str
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[Issue], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'state',
            'labels',
            'q',
            'type',
            'milestones',
            'since',
            'before',
            'created_by',
            'assigned_by',
            'mentioned_by',
            'page',
            'limit'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_list_issues" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']


        # process the query parameters
        _query_params = []
        if _params.get('state') is not None:  # noqa: E501
            _query_params.append(('state', _params['state']))

        if _params.get('labels') is not None:  # noqa: E501
            _query_params.append(('labels', _params['labels']))

        if _params.get('q') is not None:  # noqa: E501
            _query_params.append(('q', _params['q']))

        if _params.get('type') is not None:  # noqa: E501
            _query_params.append(('type', _params['type']))

        if _params.get('milestones') is not None:  # noqa: E501
            _query_params.append(('milestones', _params['milestones']))

        if _params.get('since') is not None:  # noqa: E501
            if isinstance(_params['since'], datetime):
                _query_params.append(('since', _params['since'].strftime(self.api_client.configuration.datetime_format)))
            else:
                _query_params.append(('since', _params['since']))

        if _params.get('before') is not None:  # noqa: E501
            if isinstance(_params['before'], datetime):
                _query_params.append(('before', _params['before'].strftime(self.api_client.configuration.datetime_format)))
            else:
                _query_params.append(('before', _params['before']))

        if _params.get('created_by') is not None:  # noqa: E501
            _query_params.append(('created_by', _params['created_by']))

        if _params.get('assigned_by') is not None:  # noqa: E501
            _query_params.append(('assigned_by', _params['assigned_by']))

        if _params.get('mentioned_by') is not None:  # noqa: E501
            _query_params.append(('mentioned_by', _params['mentioned_by']))

        if _params.get('page') is not None:  # noqa: E501
            _query_params.append(('page', _params['page']))

        if _params.get('limit') is not None:  # noqa: E501
            _query_params.append(('limit', _params['limit']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "List[Issue]",
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_list_labels(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], 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, **kwargs) -> List[Label]:  # noqa: E501
        ...

    @overload
    def issue_list_labels(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], 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, async_req: Optional[bool]=True, **kwargs) -> List[Label]:  # noqa: E501
        ...

    @validate_arguments
    def issue_list_labels(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], 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, async_req: Optional[bool]=None, **kwargs) -> Union[List[Label], Awaitable[List[Label]]]:  # noqa: E501
        """Get all of a repository's labels  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_list_labels(owner, repo, page, limit, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[Label]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_list_labels_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_list_labels_with_http_info(owner, repo, page, limit, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_list_labels_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], 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, **kwargs) -> ApiResponse:  # noqa: E501
        """Get all of a repository's labels  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_list_labels_with_http_info(owner, repo, page, limit, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[Label], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'page',
            'limit'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_list_labels" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']


        # process the query parameters
        _query_params = []
        if _params.get('page') is not None:  # noqa: E501
            _query_params.append(('page', _params['page']))

        if _params.get('limit') is not None:  # noqa: E501
            _query_params.append(('limit', _params['limit']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "List[Label]",
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/labels', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_post_comment_reaction(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], content : Optional[EditReactionOption] = None, **kwargs) -> Reaction:  # noqa: E501
        ...

    @overload
    def issue_post_comment_reaction(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], content : Optional[EditReactionOption] = None, async_req: Optional[bool]=True, **kwargs) -> Reaction:  # noqa: E501
        ...

    @validate_arguments
    def issue_post_comment_reaction(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], content : Optional[EditReactionOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Reaction, Awaitable[Reaction]]:  # noqa: E501
        """Add a reaction to a comment of an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_post_comment_reaction(owner, repo, id, content, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment to edit (required)
        :type id: int
        :param content:
        :type content: EditReactionOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Reaction
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_post_comment_reaction_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_post_comment_reaction_with_http_info(owner, repo, id, content, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_post_comment_reaction_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], id : Annotated[StrictInt, Field(..., description="id of the comment to edit")], content : Optional[EditReactionOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Add a reaction to a comment of an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_post_comment_reaction_with_http_info(owner, repo, id, content, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param id: id of the comment to edit (required)
        :type id: int
        :param content:
        :type content: EditReactionOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Reaction, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'id',
            'content'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_post_comment_reaction" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['content'] is not None:
            _body_params = _params['content']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '200': "Reaction",
            '201': "Reaction",
            '403': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/comments/{id}/reactions', 'POST',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_post_issue_reaction(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], content : Optional[EditReactionOption] = None, **kwargs) -> Reaction:  # noqa: E501
        ...

    @overload
    def issue_post_issue_reaction(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], content : Optional[EditReactionOption] = None, async_req: Optional[bool]=True, **kwargs) -> Reaction:  # noqa: E501
        ...

    @validate_arguments
    def issue_post_issue_reaction(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], content : Optional[EditReactionOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Reaction, Awaitable[Reaction]]:  # noqa: E501
        """Add a reaction to an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_post_issue_reaction(owner, repo, index, content, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param content:
        :type content: EditReactionOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: Reaction
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_post_issue_reaction_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_post_issue_reaction_with_http_info(owner, repo, index, content, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_post_issue_reaction_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], content : Optional[EditReactionOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Add a reaction to an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_post_issue_reaction_with_http_info(owner, repo, index, content, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param content:
        :type content: EditReactionOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(Reaction, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'content'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_post_issue_reaction" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['content'] is not None:
            _body_params = _params['content']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '200': "Reaction",
            '201': "Reaction",
            '403': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/reactions', 'POST',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_remove_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], id : Annotated[StrictInt, Field(..., description="id of the label to remove")], **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_remove_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], id : Annotated[StrictInt, Field(..., description="id of the label to remove")], async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_remove_label(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], id : Annotated[StrictInt, Field(..., description="id of the label to remove")], async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Remove a label from an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_remove_label(owner, repo, index, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param id: id of the label to remove (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_remove_label_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_remove_label_with_http_info(owner, repo, index, id, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_remove_label_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], id : Annotated[StrictInt, Field(..., description="id of the label to remove")], **kwargs) -> ApiResponse:  # noqa: E501
        """Remove a label from an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_remove_label_with_http_info(owner, repo, index, id, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param id: id of the label to remove (required)
        :type id: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_remove_label" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']

        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # authentication setting
        _auth_settings = ['TOTPHeader', 'AuthorizationHeaderToken', 'SudoHeader', 'BasicAuth', 'AccessToken', 'SudoParam', 'Token']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/labels/{id}', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_replace_labels(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], body : Optional[IssueLabelsOption] = None, **kwargs) -> List[Label]:  # noqa: E501
        ...

    @overload
    def issue_replace_labels(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], body : Optional[IssueLabelsOption] = None, async_req: Optional[bool]=True, **kwargs) -> List[Label]:  # noqa: E501
        ...

    @validate_arguments
    def issue_replace_labels(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], body : Optional[IssueLabelsOption] = None, async_req: Optional[bool]=None, **kwargs) -> Union[List[Label], Awaitable[List[Label]]]:  # noqa: E501
        """Replace an issue's labels  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_replace_labels(owner, repo, index, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param body:
        :type body: IssueLabelsOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[Label]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_replace_labels_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_replace_labels_with_http_info(owner, repo, index, body, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_replace_labels_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], body : Optional[IssueLabelsOption] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Replace an issue's labels  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_replace_labels_with_http_info(owner, repo, index, body, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param body:
        :type body: IssueLabelsOption
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[Label], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'body'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_replace_labels" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['body'] is not None:
            _body_params = _params['body']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

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

        _response_types_map = {
            '200': "List[Label]",
            '403': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/labels', 'PUT',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_reset_time(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to add tracked time to")], **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_reset_time(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to add tracked time to")], async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_reset_time(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to add tracked time to")], async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Reset a tracked time of an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_reset_time(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue to add tracked time to (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_reset_time_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_reset_time_with_http_info(owner, repo, index, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_reset_time_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to add tracked time to")], **kwargs) -> ApiResponse:  # noqa: E501
        """Reset a tracked time of an issue  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_reset_time_with_http_info(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue to add tracked time to (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_reset_time" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # authentication setting
        _auth_settings = ['TOTPHeader', 'AuthorizationHeaderToken', 'SudoHeader', 'BasicAuth', 'AccessToken', 'SudoParam', 'Token']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/times', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_search_issues(self, state : Annotated[Optional[StrictStr], Field(description="whether issue is open or closed")] = None, labels : Annotated[Optional[StrictStr], Field(description="comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded")] = None, milestones : Annotated[Optional[StrictStr], Field(description="comma separated list of milestone names. Fetch only issues that have any of this milestones. Non existent are discarded")] = None, q : Annotated[Optional[StrictStr], Field(description="search string")] = None, priority_repo_id : Annotated[Optional[StrictInt], Field(description="repository to prioritize in the results")] = None, type : Annotated[Optional[StrictStr], Field(description="filter by type (issues / pulls) if set")] = 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, assigned : Annotated[Optional[StrictBool], Field(description="filter (issues / pulls) assigned to you, default is false")] = None, created : Annotated[Optional[StrictBool], Field(description="filter (issues / pulls) created by you, default is false")] = None, mentioned : Annotated[Optional[StrictBool], Field(description="filter (issues / pulls) mentioning you, default is false")] = None, review_requested : Annotated[Optional[StrictBool], Field(description="filter pulls requesting your review, default is false")] = None, owner : Annotated[Optional[StrictStr], Field(description="filter by owner")] = None, team : Annotated[Optional[StrictStr], Field(description="filter by team (requires organization owner parameter to be provided)")] = 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, **kwargs) -> List[Issue]:  # noqa: E501
        ...

    @overload
    def issue_search_issues(self, state : Annotated[Optional[StrictStr], Field(description="whether issue is open or closed")] = None, labels : Annotated[Optional[StrictStr], Field(description="comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded")] = None, milestones : Annotated[Optional[StrictStr], Field(description="comma separated list of milestone names. Fetch only issues that have any of this milestones. Non existent are discarded")] = None, q : Annotated[Optional[StrictStr], Field(description="search string")] = None, priority_repo_id : Annotated[Optional[StrictInt], Field(description="repository to prioritize in the results")] = None, type : Annotated[Optional[StrictStr], Field(description="filter by type (issues / pulls) if set")] = 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, assigned : Annotated[Optional[StrictBool], Field(description="filter (issues / pulls) assigned to you, default is false")] = None, created : Annotated[Optional[StrictBool], Field(description="filter (issues / pulls) created by you, default is false")] = None, mentioned : Annotated[Optional[StrictBool], Field(description="filter (issues / pulls) mentioning you, default is false")] = None, review_requested : Annotated[Optional[StrictBool], Field(description="filter pulls requesting your review, default is false")] = None, owner : Annotated[Optional[StrictStr], Field(description="filter by owner")] = None, team : Annotated[Optional[StrictStr], Field(description="filter by team (requires organization owner parameter to be provided)")] = 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, async_req: Optional[bool]=True, **kwargs) -> List[Issue]:  # noqa: E501
        ...

    @validate_arguments
    def issue_search_issues(self, state : Annotated[Optional[StrictStr], Field(description="whether issue is open or closed")] = None, labels : Annotated[Optional[StrictStr], Field(description="comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded")] = None, milestones : Annotated[Optional[StrictStr], Field(description="comma separated list of milestone names. Fetch only issues that have any of this milestones. Non existent are discarded")] = None, q : Annotated[Optional[StrictStr], Field(description="search string")] = None, priority_repo_id : Annotated[Optional[StrictInt], Field(description="repository to prioritize in the results")] = None, type : Annotated[Optional[StrictStr], Field(description="filter by type (issues / pulls) if set")] = 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, assigned : Annotated[Optional[StrictBool], Field(description="filter (issues / pulls) assigned to you, default is false")] = None, created : Annotated[Optional[StrictBool], Field(description="filter (issues / pulls) created by you, default is false")] = None, mentioned : Annotated[Optional[StrictBool], Field(description="filter (issues / pulls) mentioning you, default is false")] = None, review_requested : Annotated[Optional[StrictBool], Field(description="filter pulls requesting your review, default is false")] = None, owner : Annotated[Optional[StrictStr], Field(description="filter by owner")] = None, team : Annotated[Optional[StrictStr], Field(description="filter by team (requires organization owner parameter to be provided)")] = 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, async_req: Optional[bool]=None, **kwargs) -> Union[List[Issue], Awaitable[List[Issue]]]:  # noqa: E501
        """Search for issues across the repositories that the user has access to  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_search_issues(state, labels, milestones, q, priority_repo_id, type, since, before, assigned, created, mentioned, review_requested, owner, team, page, limit, async_req=True)
        >>> result = thread.get()

        :param state: whether issue is open or closed
        :type state: str
        :param labels: comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded
        :type labels: str
        :param milestones: comma separated list of milestone names. Fetch only issues that have any of this milestones. Non existent are discarded
        :type milestones: str
        :param q: search string
        :type q: str
        :param priority_repo_id: repository to prioritize in the results
        :type priority_repo_id: int
        :param type: filter by type (issues / pulls) if set
        :type type: 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 assigned: filter (issues / pulls) assigned to you, default is false
        :type assigned: bool
        :param created: filter (issues / pulls) created by you, default is false
        :type created: bool
        :param mentioned: filter (issues / pulls) mentioning you, default is false
        :type mentioned: bool
        :param review_requested: filter pulls requesting your review, default is false
        :type review_requested: bool
        :param owner: filter by owner
        :type owner: str
        :param team: filter by team (requires organization owner parameter to be provided)
        :type team: str
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[Issue]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_search_issues_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_search_issues_with_http_info(state, labels, milestones, q, priority_repo_id, type, since, before, assigned, created, mentioned, review_requested, owner, team, page, limit, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_search_issues_with_http_info(self, state : Annotated[Optional[StrictStr], Field(description="whether issue is open or closed")] = None, labels : Annotated[Optional[StrictStr], Field(description="comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded")] = None, milestones : Annotated[Optional[StrictStr], Field(description="comma separated list of milestone names. Fetch only issues that have any of this milestones. Non existent are discarded")] = None, q : Annotated[Optional[StrictStr], Field(description="search string")] = None, priority_repo_id : Annotated[Optional[StrictInt], Field(description="repository to prioritize in the results")] = None, type : Annotated[Optional[StrictStr], Field(description="filter by type (issues / pulls) if set")] = 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, assigned : Annotated[Optional[StrictBool], Field(description="filter (issues / pulls) assigned to you, default is false")] = None, created : Annotated[Optional[StrictBool], Field(description="filter (issues / pulls) created by you, default is false")] = None, mentioned : Annotated[Optional[StrictBool], Field(description="filter (issues / pulls) mentioning you, default is false")] = None, review_requested : Annotated[Optional[StrictBool], Field(description="filter pulls requesting your review, default is false")] = None, owner : Annotated[Optional[StrictStr], Field(description="filter by owner")] = None, team : Annotated[Optional[StrictStr], Field(description="filter by team (requires organization owner parameter to be provided)")] = 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, **kwargs) -> ApiResponse:  # noqa: E501
        """Search for issues across the repositories that the user has access to  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_search_issues_with_http_info(state, labels, milestones, q, priority_repo_id, type, since, before, assigned, created, mentioned, review_requested, owner, team, page, limit, async_req=True)
        >>> result = thread.get()

        :param state: whether issue is open or closed
        :type state: str
        :param labels: comma separated list of labels. Fetch only issues that have any of this labels. Non existent labels are discarded
        :type labels: str
        :param milestones: comma separated list of milestone names. Fetch only issues that have any of this milestones. Non existent are discarded
        :type milestones: str
        :param q: search string
        :type q: str
        :param priority_repo_id: repository to prioritize in the results
        :type priority_repo_id: int
        :param type: filter by type (issues / pulls) if set
        :type type: 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 assigned: filter (issues / pulls) assigned to you, default is false
        :type assigned: bool
        :param created: filter (issues / pulls) created by you, default is false
        :type created: bool
        :param mentioned: filter (issues / pulls) mentioning you, default is false
        :type mentioned: bool
        :param review_requested: filter pulls requesting your review, default is false
        :type review_requested: bool
        :param owner: filter by owner
        :type owner: str
        :param team: filter by team (requires organization owner parameter to be provided)
        :type team: str
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[Issue], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'state',
            'labels',
            'milestones',
            'q',
            'priority_repo_id',
            'type',
            'since',
            'before',
            'assigned',
            'created',
            'mentioned',
            'review_requested',
            'owner',
            'team',
            'page',
            'limit'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_search_issues" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}

        # process the query parameters
        _query_params = []
        if _params.get('state') is not None:  # noqa: E501
            _query_params.append(('state', _params['state']))

        if _params.get('labels') is not None:  # noqa: E501
            _query_params.append(('labels', _params['labels']))

        if _params.get('milestones') is not None:  # noqa: E501
            _query_params.append(('milestones', _params['milestones']))

        if _params.get('q') is not None:  # noqa: E501
            _query_params.append(('q', _params['q']))

        if _params.get('priority_repo_id') is not None:  # noqa: E501
            _query_params.append(('priority_repo_id', _params['priority_repo_id']))

        if _params.get('type') is not None:  # noqa: E501
            _query_params.append(('type', _params['type']))

        if _params.get('since') is not None:  # noqa: E501
            if isinstance(_params['since'], datetime):
                _query_params.append(('since', _params['since'].strftime(self.api_client.configuration.datetime_format)))
            else:
                _query_params.append(('since', _params['since']))

        if _params.get('before') is not None:  # noqa: E501
            if isinstance(_params['before'], datetime):
                _query_params.append(('before', _params['before'].strftime(self.api_client.configuration.datetime_format)))
            else:
                _query_params.append(('before', _params['before']))

        if _params.get('assigned') is not None:  # noqa: E501
            _query_params.append(('assigned', _params['assigned']))

        if _params.get('created') is not None:  # noqa: E501
            _query_params.append(('created', _params['created']))

        if _params.get('mentioned') is not None:  # noqa: E501
            _query_params.append(('mentioned', _params['mentioned']))

        if _params.get('review_requested') is not None:  # noqa: E501
            _query_params.append(('review_requested', _params['review_requested']))

        if _params.get('owner') is not None:  # noqa: E501
            _query_params.append(('owner', _params['owner']))

        if _params.get('team') is not None:  # noqa: E501
            _query_params.append(('team', _params['team']))

        if _params.get('page') is not None:  # noqa: E501
            _query_params.append(('page', _params['page']))

        if _params.get('limit') is not None:  # noqa: E501
            _query_params.append(('limit', _params['limit']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "List[Issue]",
        }

        return self.api_client.call_api(
            '/repos/issues/search', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_start_stop_watch(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to create the stopwatch on")], **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_start_stop_watch(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to create the stopwatch on")], async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_start_stop_watch(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to create the stopwatch on")], async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Start stopwatch on an issue.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_start_stop_watch(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue to create the stopwatch on (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_start_stop_watch_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_start_stop_watch_with_http_info(owner, repo, index, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_start_stop_watch_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to create the stopwatch on")], **kwargs) -> ApiResponse:  # noqa: E501
        """Start stopwatch on an issue.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_start_stop_watch_with_http_info(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue to create the stopwatch on (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_start_stop_watch" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # authentication setting
        _auth_settings = ['TOTPHeader', 'AuthorizationHeaderToken', 'SudoHeader', 'BasicAuth', 'AccessToken', 'SudoParam', 'Token']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/stopwatch/start', 'POST',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_stop_stop_watch(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to stop the stopwatch on")], **kwargs) -> None:  # noqa: E501
        ...

    @overload
    def issue_stop_stop_watch(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to stop the stopwatch on")], async_req: Optional[bool]=True, **kwargs) -> None:  # noqa: E501
        ...

    @validate_arguments
    def issue_stop_stop_watch(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to stop the stopwatch on")], async_req: Optional[bool]=None, **kwargs) -> Union[None, Awaitable[None]]:  # noqa: E501
        """Stop an issue's existing stopwatch.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_stop_stop_watch(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue to stop the stopwatch on (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_stop_stop_watch_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_stop_stop_watch_with_http_info(owner, repo, index, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_stop_stop_watch_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue to stop the stopwatch on")], **kwargs) -> ApiResponse:  # noqa: E501
        """Stop an issue's existing stopwatch.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_stop_stop_watch_with_http_info(owner, repo, index, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue to stop the stopwatch on (required)
        :type index: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_stop_stop_watch" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # authentication setting
        _auth_settings = ['TOTPHeader', 'AuthorizationHeaderToken', 'SudoHeader', 'BasicAuth', 'AccessToken', 'SudoParam', 'Token']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/stopwatch/stop', 'POST',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_subscriptions(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], 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, **kwargs) -> List[User]:  # noqa: E501
        ...

    @overload
    def issue_subscriptions(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], 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, async_req: Optional[bool]=True, **kwargs) -> List[User]:  # noqa: E501
        ...

    @validate_arguments
    def issue_subscriptions(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], 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, async_req: Optional[bool]=None, **kwargs) -> Union[List[User], Awaitable[List[User]]]:  # noqa: E501
        """Get users who subscribed on an issue.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_subscriptions(owner, repo, index, page, limit, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[User]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_subscriptions_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_subscriptions_with_http_info(owner, repo, index, page, limit, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_subscriptions_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], 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, **kwargs) -> ApiResponse:  # noqa: E501
        """Get users who subscribed on an issue.  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_subscriptions_with_http_info(owner, repo, index, page, limit, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param page: page number of results to return (1-based)
        :type page: int
        :param limit: page size of results
        :type limit: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[User], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'page',
            'limit'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_subscriptions" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        if _params.get('page') is not None:  # noqa: E501
            _query_params.append(('page', _params['page']))

        if _params.get('limit') is not None:  # noqa: E501
            _query_params.append(('limit', _params['limit']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "List[User]",
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/subscriptions', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @overload
    async def issue_tracked_times(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], user : Annotated[Optional[StrictStr], Field(description="optional filter by user (available for issue managers)")] = None, since : Annotated[Optional[datetime], Field(description="Only show times updated after the given time. This is a timestamp in RFC 3339 format")] = None, before : Annotated[Optional[datetime], Field(description="Only show times 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, **kwargs) -> List[TrackedTime]:  # noqa: E501
        ...

    @overload
    def issue_tracked_times(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], user : Annotated[Optional[StrictStr], Field(description="optional filter by user (available for issue managers)")] = None, since : Annotated[Optional[datetime], Field(description="Only show times updated after the given time. This is a timestamp in RFC 3339 format")] = None, before : Annotated[Optional[datetime], Field(description="Only show times 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, async_req: Optional[bool]=True, **kwargs) -> List[TrackedTime]:  # noqa: E501
        ...

    @validate_arguments
    def issue_tracked_times(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], user : Annotated[Optional[StrictStr], Field(description="optional filter by user (available for issue managers)")] = None, since : Annotated[Optional[datetime], Field(description="Only show times updated after the given time. This is a timestamp in RFC 3339 format")] = None, before : Annotated[Optional[datetime], Field(description="Only show times 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, async_req: Optional[bool]=None, **kwargs) -> Union[List[TrackedTime], Awaitable[List[TrackedTime]]]:  # noqa: E501
        """List an issue's tracked times  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_tracked_times(owner, repo, index, user, since, before, page, limit, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param user: optional filter by user (available for issue managers)
        :type user: str
        :param since: Only show times updated after the given time. This is a timestamp in RFC 3339 format
        :type since: datetime
        :param before: Only show times 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 async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[TrackedTime]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the issue_tracked_times_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        if async_req is not None:
            kwargs['async_req'] = async_req
        return self.issue_tracked_times_with_http_info(owner, repo, index, user, since, before, page, limit, **kwargs)  # noqa: E501

    @validate_arguments
    def issue_tracked_times_with_http_info(self, owner : Annotated[StrictStr, Field(..., description="owner of the repo")], repo : Annotated[StrictStr, Field(..., description="name of the repo")], index : Annotated[StrictInt, Field(..., description="index of the issue")], user : Annotated[Optional[StrictStr], Field(description="optional filter by user (available for issue managers)")] = None, since : Annotated[Optional[datetime], Field(description="Only show times updated after the given time. This is a timestamp in RFC 3339 format")] = None, before : Annotated[Optional[datetime], Field(description="Only show times 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, **kwargs) -> ApiResponse:  # noqa: E501
        """List an issue's tracked times  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.issue_tracked_times_with_http_info(owner, repo, index, user, since, before, page, limit, async_req=True)
        >>> result = thread.get()

        :param owner: owner of the repo (required)
        :type owner: str
        :param repo: name of the repo (required)
        :type repo: str
        :param index: index of the issue (required)
        :type index: int
        :param user: optional filter by user (available for issue managers)
        :type user: str
        :param since: Only show times updated after the given time. This is a timestamp in RFC 3339 format
        :type since: datetime
        :param before: Only show times 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 async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[TrackedTime], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'owner',
            'repo',
            'index',
            'user',
            'since',
            'before',
            'page',
            'limit'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method issue_tracked_times" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['owner']:
            _path_params['owner'] = _params['owner']

        if _params['repo']:
            _path_params['repo'] = _params['repo']

        if _params['index']:
            _path_params['index'] = _params['index']


        # process the query parameters
        _query_params = []
        if _params.get('user') is not None:  # noqa: E501
            _query_params.append(('user', _params['user']))

        if _params.get('since') is not None:  # noqa: E501
            if isinstance(_params['since'], datetime):
                _query_params.append(('since', _params['since'].strftime(self.api_client.configuration.datetime_format)))
            else:
                _query_params.append(('since', _params['since']))

        if _params.get('before') is not None:  # noqa: E501
            if isinstance(_params['before'], datetime):
                _query_params.append(('before', _params['before'].strftime(self.api_client.configuration.datetime_format)))
            else:
                _query_params.append(('before', _params['before']))

        if _params.get('page') is not None:  # noqa: E501
            _query_params.append(('page', _params['page']))

        if _params.get('limit') is not None:  # noqa: E501
            _query_params.append(('limit', _params['limit']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

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

        _response_types_map = {
            '200': "List[TrackedTime]",
            '404': None,
        }

        return self.api_client.call_api(
            '/repos/{owner}/{repo}/issues/{index}/times', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))
