diff --git a/github/Team.py b/github/Team.py
index 18d9f7ee..38b605ed 100644
--- a/github/Team.py
+++ b/github/Team.py
@@ -38,164 +38,142 @@
 # along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
 #                                                                              #
 ################################################################################
+from __future__ import annotations
 
-from typing import Any, Dict
+from typing import TYPE_CHECKING, Any
 
 from deprecated import deprecated
 
-import github.GithubObject
 import github.NamedUser
 import github.Organization
 import github.PaginatedList
 import github.Repository
 import github.TeamDiscussion
+from github import Consts
 from github.GithubException import UnknownObjectException
+from github.GithubObject import Attribute, CompletableGithubObject, NotSet, Opt
 
-from . import Consts
+if TYPE_CHECKING:
+    from github.Membership import Membership
+    from github.NamedUser import NamedUser
+    from github.Organization import Organization
+    from github.PaginatedList import PaginatedList
+    from github.Permissions import Permissions
+    from github.Repository import Repository
+    from github.TeamDiscussion import TeamDiscussion
 
 
-class Team(github.GithubObject.CompletableGithubObject):
+class Team(CompletableGithubObject):
     """
     This class represents Teams. The reference can be found here https://docs.github.com/en/rest/reference/teams
     """
 
+    def _initAttributes(self) -> None:
+        self._id: Attribute[int] = NotSet
+        self._members_count: Attribute[int] = NotSet
+        self._members_url: Attribute[str] = NotSet
+        self._name: Attribute[str] = NotSet
+        self._description: Attribute[str] = NotSet
+        self._permission: Attribute[str] = NotSet
+        self._repos_count: Attribute[int] = NotSet
+        self._repositories_url: Attribute[str] = NotSet
+        self._slug: Attribute[str] = NotSet
+        self._url: Attribute[str] = NotSet
+        self._organization: Attribute[github.Organization.Organization] = NotSet
+        self._privacy: Attribute[str] = NotSet
+        self._parent: Attribute[github.Team.Team] = NotSet
+        self._html_url: Attribute[str] = NotSet
+
     def __repr__(self) -> str:
         return self.get__repr__({"id": self._id.value, "name": self._name.value})
 
     @property
-    def id(self):
-        """
-        :type: integer
-        """
+    def id(self) -> int:
         self._completeIfNotSet(self._id)
         return self._id.value
 
     @property
-    def members_count(self):
-        """
-        :type: integer
-        """
+    def members_count(self) -> int:
         self._completeIfNotSet(self._members_count)
         return self._members_count.value
 
     @property
-    def members_url(self):
-        """
-        :type: string
-        """
+    def members_url(self) -> str:
         self._completeIfNotSet(self._members_url)
         return self._members_url.value
 
     @property
-    def name(self):
-        """
-        :type: string
-        """
+    def name(self) -> str:
         self._completeIfNotSet(self._name)
         return self._name.value
 
     @property
-    def description(self):
-        """
-        :type: string
-        """
+    def description(self) -> str:
         self._completeIfNotSet(self._description)
         return self._description.value
 
     @property
-    def permission(self):
-        """
-        :type: string
-        """
+    def permission(self) -> str:
         self._completeIfNotSet(self._permission)
         return self._permission.value
 
     @property
-    def repos_count(self):
-        """
-        :type: integer
-        """
+    def repos_count(self) -> int:
         self._completeIfNotSet(self._repos_count)
         return self._repos_count.value
 
     @property
-    def repositories_url(self):
-        """
-        :type: string
-        """
+    def repositories_url(self) -> str:
         self._completeIfNotSet(self._repositories_url)
         return self._repositories_url.value
 
     @property
-    def slug(self):
-        """
-        :type: string
-        """
+    def slug(self) -> str:
         self._completeIfNotSet(self._slug)
         return self._slug.value
 
     @property
-    def url(self):
-        """
-        :type: string
-        """
+    def url(self) -> str:
         self._completeIfNotSet(self._url)
         return self._url.value
 
     @property
-    def organization(self):
-        """
-        :type: :class:`github.Organization.Organization`
-        """
+    def organization(self) -> Organization:
         self._completeIfNotSet(self._organization)
         return self._organization.value
 
     @property
-    def privacy(self):
-        """
-        :type: string
-        """
+    def privacy(self) -> str:
         self._completeIfNotSet(self._privacy)
         return self._privacy.value
 
     @property
-    def parent(self):
-        """
-        :type: string
-        """
+    def parent(self) -> Team:
         self._completeIfNotSet(self._parent)
         return self._parent.value
 
     @property
-    def html_url(self):
-        """
-        :type: string
-        """
+    def html_url(self) -> str:
         self._completeIfNotSet(self._html_url)
         return self._html_url.value
 
-    def add_to_members(self, member):
+    def add_to_members(self, member: NamedUser) -> None:
         """
         This API call is deprecated. Use `add_membership` instead.
         https://docs.github.com/en/rest/reference/teams#add-or-update-team-membership-for-a-user-legacy
 
         :calls: `PUT /teams/{id}/members/{user} <https://docs.github.com/en/rest/reference/teams>`_
-        :param member: :class:`github.NamedUser.NamedUser`
-        :rtype: None
         """
         assert isinstance(member, github.NamedUser.NamedUser), member
         headers, data = self._requester.requestJsonAndCheck("PUT", f"{self.url}/members/{member._identity}")
 
-    def add_membership(self, member, role=github.GithubObject.NotSet):
+    def add_membership(self, member: NamedUser, role: Opt[str] = NotSet) -> None:
         """
         :calls: `PUT /teams/{id}/memberships/{user} <https://docs.github.com/en/rest/reference/teams>`_
-        :param member: :class:`github.Nameduser.NamedUser`
-        :param role: string
-        :rtype: None
         """
         assert isinstance(member, github.NamedUser.NamedUser), member
-        assert role is github.GithubObject.NotSet or isinstance(role, str), role
-        if role is not github.GithubObject.NotSet:
+        assert role is NotSet or isinstance(role, str), role
+        if role is not NotSet:
             assert role in ["member", "maintainer"]
             put_parameters = {
                 "role": role,
@@ -208,11 +186,9 @@ class Team(github.GithubObject.CompletableGithubObject):
             "PUT", f"{self.url}/memberships/{member._identity}", input=put_parameters
         )
 
-    def get_team_membership(self, member):
+    def get_team_membership(self, member: str | NamedUser) -> Membership:
         """
         :calls: `GET /orgs/{org}/memberships/team/{team_id}/{username} <https://docs.github.com/en/rest/reference/teams#get-team-membership-for-a-user>`_
-        :param member: string or :class:`github.NamedUser.NamedUser`
-        :rtype: :class:`github.Membership.Membership`
         """
         assert isinstance(member, str) or isinstance(member, github.NamedUser.NamedUser), member
         if isinstance(member, github.NamedUser.NamedUser):
@@ -220,24 +196,20 @@ class Team(github.GithubObject.CompletableGithubObject):
         headers, data = self._requester.requestJsonAndCheck("GET", f"{self.url}/memberships/{member}")
         return github.Membership.Membership(self._requester, headers, data, completed=True)
 
-    def add_to_repos(self, repo):
+    def add_to_repos(self, repo: Repository) -> None:
         """
         :calls: `PUT /teams/{id}/repos/{org}/{repo} <https://docs.github.com/en/rest/reference/teams>`_
-        :param repo: :class:`github.Repository.Repository`
-        :rtype: None
         """
         assert isinstance(repo, github.Repository.Repository), repo
         headers, data = self._requester.requestJsonAndCheck("PUT", f"{self.url}/repos/{repo._identity}")
 
-    def get_repo_permission(self, repo):
+    def get_repo_permission(self, repo: Repository) -> Permissions | None:
         """
         :calls: `GET /teams/{id}/repos/{org}/{repo} <https://docs.github.com/en/rest/reference/teams>`_
-        :param repo: string or :class:`github.Repository.Repository`
-        :rtype: None or :class:`github.Permissions.Permissions`
         """
         assert isinstance(repo, github.Repository.Repository) or isinstance(repo, str), repo
         if isinstance(repo, github.Repository.Repository):
-            repo = repo._identity
+            repo = repo._identity  # type: ignore
         try:
             headers, data = self._requester.requestJsonAndCheck(
                 "GET",
@@ -253,7 +225,7 @@ class Team(github.GithubObject.CompletableGithubObject):
         Team.set_repo_permission() is deprecated, use Team.update_team_repository() instead.
         """
     )
-    def set_repo_permission(self, repo, permission):
+    def set_repo_permission(self, repo: Repository, permission: str) -> None:
         """
         :calls: `PUT /teams/{id}/repos/{org}/{repo} <https://docs.github.com/en/rest/reference/teams>`_
         :param repo: :class:`github.Repository.Repository`
@@ -269,18 +241,16 @@ class Team(github.GithubObject.CompletableGithubObject):
             "PUT", f"{self.url}/repos/{repo._identity}", input=put_parameters
         )
 
-    def update_team_repository(self, repo, permission):
+    def update_team_repository(self, repo: Repository, permission: str) -> bool:
         """
         :calls: `PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo} <https://docs.github.com/en/rest/reference/teams#check-team-permissions-for-a-repository>`_
-        :param repo: string or :class:`github.Repository.Repository`
-        :param permission: string
-        :rtype: bool
         """
         assert isinstance(repo, github.Repository.Repository) or isinstance(repo, str), repo
         assert isinstance(permission, str), permission
-        repo_url_param = repo
         if isinstance(repo, github.Repository.Repository):
             repo_url_param = repo._identity
+        else:
+            repo_url_param = repo
         put_parameters = {
             "permission": permission,
         }
@@ -291,48 +261,36 @@ class Team(github.GithubObject.CompletableGithubObject):
         )
         return status == 204
 
-    def delete(self):
+    def delete(self) -> None:
         """
         :calls: `DELETE /teams/{id} <https://docs.github.com/en/rest/reference/teams#delete-a-team>`_
-        :rtype: None
         """
         headers, data = self._requester.requestJsonAndCheck("DELETE", self.url)
 
     def edit(
         self,
-        name,
-        description=github.GithubObject.NotSet,
-        permission=github.GithubObject.NotSet,
-        privacy=github.GithubObject.NotSet,
-    ):
+        name: str,
+        description: Opt[str] = NotSet,
+        permission: Opt[str] = NotSet,
+        privacy: Opt[str] = NotSet,
+    ) -> None:
         """
         :calls: `PATCH /teams/{id} <https://docs.github.com/en/rest/reference/teams#update-a-team>`_
-        :param name: string
-        :param description: string
-        :param permission: string
-        :param privacy: string
-        :rtype: None
         """
         assert isinstance(name, str), name
-        assert description is github.GithubObject.NotSet or isinstance(description, str), description
-        assert permission is github.GithubObject.NotSet or isinstance(permission, str), permission
-        assert privacy is github.GithubObject.NotSet or isinstance(privacy, str), privacy
-        post_parameters = {
-            "name": name,
-        }
-        if description is not github.GithubObject.NotSet:
-            post_parameters["description"] = description
-        if permission is not github.GithubObject.NotSet:
-            post_parameters["permission"] = permission
-        if privacy is not github.GithubObject.NotSet:
-            post_parameters["privacy"] = privacy
+        assert description is NotSet or isinstance(description, str), description
+        assert permission is NotSet or isinstance(permission, str), permission
+        assert privacy is NotSet or isinstance(privacy, str), privacy
+        post_parameters = NotSet.remove_unset_items(
+            {"name": name, "description": description, "permission": permission, "privacy": privacy}
+        )
+
         headers, data = self._requester.requestJsonAndCheck("PATCH", self.url, input=post_parameters)
         self._useAttributes(data)
 
-    def get_teams(self):
+    def get_teams(self) -> PaginatedList[Team]:
         """
         :calls: `GET /teams/{id}/teams <https://docs.github.com/en/rest/reference/teams#list-teams>`_
-        :rtype: :class:`github.PaginatedList.PaginatedList` of :class:`github.Team.Team`
         """
         return github.PaginatedList.PaginatedList(
             github.Team.Team,
@@ -341,10 +299,9 @@ class Team(github.GithubObject.CompletableGithubObject):
             None,
         )
 
-    def get_discussions(self):
+    def get_discussions(self) -> PaginatedList[TeamDiscussion]:
         """
         :calls: `GET /teams/{id}/discussions <https://docs.github.com/en/rest/reference/teams#list-discussions>`_
-        :rtype: :class:`github.PaginatedList.PaginatedList` of :class:`github.TeamDiscussion.TeamDiscussion`
         """
         return github.PaginatedList.PaginatedList(
             github.TeamDiscussion.TeamDiscussion,
@@ -354,15 +311,13 @@ class Team(github.GithubObject.CompletableGithubObject):
             headers={"Accept": Consts.mediaTypeTeamDiscussionsPreview},
         )
 
-    def get_members(self, role=github.GithubObject.NotSet):
+    def get_members(self, role: Opt[str] = NotSet) -> PaginatedList[NamedUser]:
         """
         :calls: `GET /teams/{id}/members <https://docs.github.com/en/rest/reference/teams#list-team-members>`_
-        :param role: string
-        :rtype: :class:`github.PaginatedList.PaginatedList` of :class:`github.NamedUser.NamedUser`
         """
-        assert role is github.GithubObject.NotSet or isinstance(role, str), role
-        url_parameters = dict()
-        if role is not github.GithubObject.NotSet:
+        assert role is NotSet or isinstance(role, str), role
+        url_parameters: dict[str, Any] = {}
+        if role is not NotSet:
             assert role in ["member", "maintainer", "all"]
             url_parameters["role"] = role
         return github.PaginatedList.PaginatedList(
@@ -372,19 +327,17 @@ class Team(github.GithubObject.CompletableGithubObject):
             url_parameters,
         )
 
-    def get_repos(self):
+    def get_repos(self) -> PaginatedList[Repository]:
         """
         :calls: `GET /teams/{id}/repos <https://docs.github.com/en/rest/reference/teams>`_
-        :rtype: :class:`github.PaginatedList.PaginatedList` of :class:`github.Repository.Repository`
         """
         return github.PaginatedList.PaginatedList(
             github.Repository.Repository, self._requester, f"{self.url}/repos", None
         )
 
-    def invitations(self):
+    def invitations(self) -> PaginatedList[NamedUser]:
         """
         :calls: `GET /teams/{id}/invitations <https://docs.github.com/en/rest/reference/teams#members>`_
-        :rtype: :class:`github.PaginatedList.PaginatedList` of :class:`github.NamedUser.NamedUser`
         """
         return github.PaginatedList.PaginatedList(
             github.NamedUser.NamedUser,
@@ -394,77 +347,51 @@ class Team(github.GithubObject.CompletableGithubObject):
             headers={"Accept": Consts.mediaTypeOrganizationInvitationPreview},
         )
 
-    def has_in_members(self, member):
+    def has_in_members(self, member: NamedUser) -> bool:
         """
         :calls: `GET /teams/{id}/members/{user} <https://docs.github.com/en/rest/reference/teams>`_
-        :param member: :class:`github.NamedUser.NamedUser`
-        :rtype: bool
         """
         assert isinstance(member, github.NamedUser.NamedUser), member
         status, headers, data = self._requester.requestJson("GET", f"{self.url}/members/{member._identity}")
         return status == 204
 
-    def has_in_repos(self, repo):
+    def has_in_repos(self, repo: Repository) -> bool:
         """
         :calls: `GET /teams/{id}/repos/{owner}/{repo} <https://docs.github.com/en/rest/reference/teams>`_
-        :param repo: :class:`github.Repository.Repository`
-        :rtype: bool
         """
         assert isinstance(repo, github.Repository.Repository), repo
         status, headers, data = self._requester.requestJson("GET", f"{self.url}/repos/{repo._identity}")
         return status == 204
 
-    def remove_membership(self, member):
+    def remove_membership(self, member: NamedUser) -> None:
         """
         :calls: `DELETE /teams/{team_id}/memberships/{username} <https://docs.github.com/en/rest/reference/teams#remove-team-membership-for-a-user>`_
-        :param member:
-        :return:
         """
         assert isinstance(member, github.NamedUser.NamedUser), member
         headers, data = self._requester.requestJsonAndCheck("DELETE", f"{self.url}/memberships/{member._identity}")
 
-    def remove_from_members(self, member):
+    def remove_from_members(self, member: NamedUser) -> None:
         """
         This API call is deprecated. Use `remove_membership` instead:
         https://docs.github.com/en/rest/reference/teams#add-or-update-team-membership-for-a-user-legacy
 
         :calls: `DELETE /teams/{id}/members/{user} <https://docs.github.com/en/rest/reference/teams>`_
-        :param member: :class:`github.NamedUser.NamedUser`
-        :rtype: None
         """
         assert isinstance(member, github.NamedUser.NamedUser), member
         headers, data = self._requester.requestJsonAndCheck("DELETE", f"{self.url}/members/{member._identity}")
 
-    def remove_from_repos(self, repo):
+    def remove_from_repos(self, repo: Repository) -> None:
         """
         :calls: `DELETE /teams/{id}/repos/{owner}/{repo} <https://docs.github.com/en/rest/reference/teams>`_
-        :param repo: :class:`github.Repository.Repository`
-        :rtype: None
         """
         assert isinstance(repo, github.Repository.Repository), repo
         headers, data = self._requester.requestJsonAndCheck("DELETE", f"{self.url}/repos/{repo._identity}")
 
     @property
-    def _identity(self):
+    def _identity(self) -> int:
         return self.id
 
-    def _initAttributes(self) -> None:
-        self._id = github.GithubObject.NotSet
-        self._members_count = github.GithubObject.NotSet
-        self._members_url = github.GithubObject.NotSet
-        self._name = github.GithubObject.NotSet
-        self._description = github.GithubObject.NotSet
-        self._permission = github.GithubObject.NotSet
-        self._repos_count = github.GithubObject.NotSet
-        self._repositories_url = github.GithubObject.NotSet
-        self._slug = github.GithubObject.NotSet
-        self._url = github.GithubObject.NotSet
-        self._organization = github.GithubObject.NotSet
-        self._privacy = github.GithubObject.NotSet
-        self._parent = github.GithubObject.NotSet
-        self._html_url = github.GithubObject.NotSet
-
-    def _useAttributes(self, attributes: Dict[str, Any]) -> None:
+    def _useAttributes(self, attributes: dict[str, Any]) -> None:
         if "id" in attributes:  # pragma no branch
             self._id = self._makeIntAttribute(attributes["id"])
         if "members_count" in attributes:  # pragma no branch
diff --git a/github/Team.pyi b/github/Team.pyi
deleted file mode 100644
index fb3771ef..00000000
--- a/github/Team.pyi
+++ /dev/null
@@ -1,70 +0,0 @@
-from typing import Any, Dict, Union
-
-from github.GithubObject import CompletableGithubObject, _NotSetType
-from github.Membership import Membership
-from github.NamedUser import NamedUser
-from github.Organization import Organization
-from github.PaginatedList import PaginatedList
-from github.Permissions import Permissions
-from github.Repository import Repository
-from github.TeamDiscussion import TeamDiscussion
-
-class Team(CompletableGithubObject):
-    def __repr__(self) -> str: ...
-    @property
-    def _identity(self) -> int: ...
-    def _initAttributes(self) -> None: ...
-    def _useAttributes(self, attributes: Dict[str, Any]) -> None: ...
-    def add_membership(self, member: NamedUser, role: Union[str, _NotSetType] = ...) -> None: ...
-    def add_to_members(self, member: NamedUser) -> None: ...
-    def get_team_membership(self, member: Union[str, NamedUser]) -> Membership: ...
-    def add_to_repos(self, repo: Repository) -> None: ...
-    def get_repo_permission(self, repo: Repository) -> Union[Permissions, _NotSetType]: ...
-    def update_team_repository(self, repo: Repository, permission: str) -> bool: ...
-    def delete(self) -> None: ...
-    @property
-    def description(self) -> str: ...
-    def edit(
-        self,
-        name: str,
-        description: Union[str, _NotSetType] = ...,
-        permission: Union[str, _NotSetType] = ...,
-        privacy: Union[str, _NotSetType] = ...,
-    ) -> None: ...
-    def get_teams(self) -> PaginatedList[Team]: ...
-    def get_discussions(self) -> PaginatedList[TeamDiscussion]: ...
-    def get_members(self, role: Union[str, _NotSetType] = ...) -> PaginatedList[NamedUser]: ...
-    def get_repos(self) -> PaginatedList[Repository]: ...
-    def has_in_members(self, member: NamedUser) -> bool: ...
-    def has_in_repos(self, repo: Repository) -> bool: ...
-    @property
-    def id(self) -> int: ...
-    def invitations(self) -> PaginatedList[NamedUser]: ...
-    @property
-    def members_count(self) -> int: ...
-    @property
-    def members_url(self) -> str: ...
-    @property
-    def name(self) -> str: ...
-    @property
-    def organization(self) -> Organization: ...
-    @property
-    def permission(self) -> str: ...
-    @property
-    def privacy(self) -> str: ...
-    def remove_from_members(self, member: NamedUser) -> None: ...
-    def remove_from_repos(self, repo: Repository) -> None: ...
-    def remove_membership(self, member: NamedUser) -> None: ...
-    @property
-    def repos_count(self) -> int: ...
-    @property
-    def repositories_url(self) -> str: ...
-    def set_repo_permission(self, repo: Repository, permission: str) -> None: ...
-    @property
-    def slug(self) -> str: ...
-    @property
-    def url(self) -> str: ...
-    @property
-    def parent(self) -> Union[Team, _NotSetType]: ...
-    @property
-    def html_url(self) -> str: ...