I've done some more digging into the redis types, and found that the async classes (at least in core) are literally just the sync classes, but titled async. The difference is in their return type. The way this is annotated in the project is by defining every return type as T | Awaitable[T], in both the sync and async classes. Typeshed unpacks this by defining just the T in the sync class, and just the Awaitable[T] in the async one.

One thing we could do to reduce the implementation burden on typeshed is to use generics for this. It might seem a little insane at first, but the arguments are identical for both instances, and the return types are very similar in most cases. I've converted the SortedSetCommands class using this method to get a rough estimate, and we'd only need 9 TypeVars to accurately document the full class. Sample:

from typing import TypeVar, Awaitable, Generic

_IntReturn = TypeVar("_IntReturn", bound=int | Awaitable[int])
_FloatReturn = TypeVar("_FloatReturn", bound=float | Awaitable[float])
_FloatReturnOptional = TypeVar("_FloatReturnOptional", bound=float | None | Awaitable[float | None])
class _BaseSortedSetCommands(Generic[_IntReturn, _FloatReturn, _FloatReturnOptional]):
    def method_1(self) -> _IntReturn: ...
    def method_2(self) -> _FloatReturn: ...
    def method_3(self) -> _FloatReturnOptional: ...

class SortedSetCommands(_BaseSortedSetCommands[int, float, float | None]): ...
class AsyncSortedSetCommands(_BaseSortedSetCommands[Awaitable[int], Awaitable[float], Awaitable[float | None]]): ...

sync_class = SortedSetCommands()
reveal_type(sync_class.method_1())
reveal_type(sync_class.method_2())
reveal_type(sync_class.method_3())

async_class = AsyncSortedSetCommands()
reveal_type(async_class.method_1())
reveal_type(async_class.method_2())
reveal_type(async_class.method_3())

(This is a valid code sample that can be run with mypy to prove that correct types are returned)

How would we feel about something like this? Implementation can always continue as normal with the current system as well.

P.S: Shoutout to the staff at python discord for helping me figure this out.

Of note: the project itself might eventually switch to a completely different scheme for defining the sync and async APIs, one which might be typed using generics, see redis/redis-py#2119 (comment)