layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/io.pyi

@@ -0,0 +1,75 @@
+import abc
+import sys
+from _io import (
+    DEFAULT_BUFFER_SIZE as DEFAULT_BUFFER_SIZE,
+    BlockingIOError as BlockingIOError,
+    BufferedRandom as BufferedRandom,
+    BufferedReader as BufferedReader,
+    BufferedRWPair as BufferedRWPair,
+    BufferedWriter as BufferedWriter,
+    BytesIO as BytesIO,
+    FileIO as FileIO,
+    IncrementalNewlineDecoder as IncrementalNewlineDecoder,
+    StringIO as StringIO,
+    TextIOWrapper as TextIOWrapper,
+    _BufferedIOBase,
+    _IOBase,
+    _RawIOBase,
+    _TextIOBase,
+    _WrappedBuffer as _WrappedBuffer,  # used elsewhere in typeshed
+    open as open,
+    open_code as open_code,
+)
+from typing import Final, Protocol, TypeVar
+
+__all__ = [
+    "BlockingIOError",
+    "open",
+    "open_code",
+    "IOBase",
+    "RawIOBase",
+    "FileIO",
+    "BytesIO",
+    "StringIO",
+    "BufferedIOBase",
+    "BufferedReader",
+    "BufferedWriter",
+    "BufferedRWPair",
+    "BufferedRandom",
+    "TextIOBase",
+    "TextIOWrapper",
+    "UnsupportedOperation",
+    "SEEK_SET",
+    "SEEK_CUR",
+    "SEEK_END",
+]
+
+if sys.version_info >= (3, 14):
+    __all__ += ["Reader", "Writer"]
+
+if sys.version_info >= (3, 11):
+    from _io import text_encoding as text_encoding
+
+    __all__ += ["DEFAULT_BUFFER_SIZE", "IncrementalNewlineDecoder", "text_encoding"]
+
+_T_co = TypeVar("_T_co", covariant=True)
+_T_contra = TypeVar("_T_contra", contravariant=True)
+
+SEEK_SET: Final = 0
+SEEK_CUR: Final = 1
+SEEK_END: Final = 2
+
+class UnsupportedOperation(OSError, ValueError): ...
+class IOBase(_IOBase, metaclass=abc.ABCMeta): ...
+class RawIOBase(_RawIOBase, IOBase): ...
+class BufferedIOBase(_BufferedIOBase, IOBase): ...
+class TextIOBase(_TextIOBase, IOBase): ...
+
+if sys.version_info >= (3, 14):
+    class Reader(Protocol[_T_co]):
+        __slots__ = ()
+        def read(self, size: int = ..., /) -> _T_co: ...
+
+    class Writer(Protocol[_T_contra]):
+        __slots__ = ()
+        def write(self, data: _T_contra, /) -> int: ...

package/analyzers/project-map-python/typeshed/stdlib/ipaddress.pyi

@@ -0,0 +1,249 @@
+import sys
+from collections.abc import Iterable, Iterator
+from typing import Any, Final, Generic, Literal, TypeAlias, TypeVar, overload
+from typing_extensions import Self
+
+# Undocumented length constants
+IPV4LENGTH: Final = 32
+IPV6LENGTH: Final = 128
+
+_A = TypeVar("_A", IPv4Address, IPv6Address)
+_N = TypeVar("_N", IPv4Network, IPv6Network)
+
+_RawIPAddress: TypeAlias = int | str | bytes | IPv4Address | IPv6Address
+_RawNetworkPart: TypeAlias = IPv4Network | IPv6Network | IPv4Interface | IPv6Interface
+
+def ip_address(address: _RawIPAddress) -> IPv4Address | IPv6Address: ...
+def ip_network(
+    address: _RawIPAddress | _RawNetworkPart | tuple[_RawIPAddress] | tuple[_RawIPAddress, int], strict: bool = True
+) -> IPv4Network | IPv6Network: ...
+def ip_interface(
+    address: _RawIPAddress | _RawNetworkPart | tuple[_RawIPAddress] | tuple[_RawIPAddress, int],
+) -> IPv4Interface | IPv6Interface: ...
+
+class _IPAddressBase:
+    __slots__ = ()
+    @property
+    def compressed(self) -> str: ...
+    @property
+    def exploded(self) -> str: ...
+    @property
+    def reverse_pointer(self) -> str: ...
+    if sys.version_info < (3, 14):
+        @property
+        def version(self) -> int: ...
+
+class _BaseAddress(_IPAddressBase):
+    __slots__ = ()
+    def __add__(self, other: int) -> Self: ...
+    def __hash__(self) -> int: ...
+    def __int__(self) -> int: ...
+    def __sub__(self, other: int) -> Self: ...
+    def __format__(self, fmt: str) -> str: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __lt__(self, other: Self) -> bool: ...
+    if sys.version_info >= (3, 11):
+        def __ge__(self, other: Self) -> bool: ...
+        def __gt__(self, other: Self) -> bool: ...
+        def __le__(self, other: Self) -> bool: ...
+    else:
+        def __ge__(self, other: Self, NotImplemented: Any = ...) -> bool: ...
+        def __gt__(self, other: Self, NotImplemented: Any = ...) -> bool: ...
+        def __le__(self, other: Self, NotImplemented: Any = ...) -> bool: ...
+
+class _BaseNetwork(_IPAddressBase, Generic[_A]):
+    network_address: _A
+    netmask: _A
+    def __contains__(self, other: Any) -> bool: ...
+    def __getitem__(self, n: int) -> _A: ...
+    def __iter__(self) -> Iterator[_A]: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __lt__(self, other: Self) -> bool: ...
+    if sys.version_info >= (3, 11):
+        def __ge__(self, other: Self) -> bool: ...
+        def __gt__(self, other: Self) -> bool: ...
+        def __le__(self, other: Self) -> bool: ...
+    else:
+        def __ge__(self, other: Self, NotImplemented: Any = ...) -> bool: ...
+        def __gt__(self, other: Self, NotImplemented: Any = ...) -> bool: ...
+        def __le__(self, other: Self, NotImplemented: Any = ...) -> bool: ...
+
+    def address_exclude(self, other: Self) -> Iterator[Self]: ...
+    @property
+    def broadcast_address(self) -> _A: ...
+    def compare_networks(self, other: Self) -> int: ...
+    def hosts(self) -> Iterator[_A]: ...
+    @property
+    def is_global(self) -> bool: ...
+    @property
+    def is_link_local(self) -> bool: ...
+    @property
+    def is_loopback(self) -> bool: ...
+    @property
+    def is_multicast(self) -> bool: ...
+    @property
+    def is_private(self) -> bool: ...
+    @property
+    def is_reserved(self) -> bool: ...
+    @property
+    def is_unspecified(self) -> bool: ...
+    @property
+    def num_addresses(self) -> int: ...
+    def overlaps(self, other: _BaseNetwork[IPv4Address] | _BaseNetwork[IPv6Address]) -> bool: ...
+    @property
+    def prefixlen(self) -> int: ...
+    def subnet_of(self, other: Self) -> bool: ...
+    def supernet_of(self, other: Self) -> bool: ...
+    def subnets(self, prefixlen_diff: int = 1, new_prefix: int | None = None) -> Iterator[Self]: ...
+    def supernet(self, prefixlen_diff: int = 1, new_prefix: int | None = None) -> Self: ...
+    @property
+    def with_hostmask(self) -> str: ...
+    @property
+    def with_netmask(self) -> str: ...
+    @property
+    def with_prefixlen(self) -> str: ...
+    @property
+    def hostmask(self) -> _A: ...
+
+class _BaseV4:
+    __slots__ = ()
+    if sys.version_info >= (3, 14):
+        version: Final = 4
+        max_prefixlen: Final = 32
+    else:
+        @property
+        def version(self) -> Literal[4]: ...
+        @property
+        def max_prefixlen(self) -> Literal[32]: ...
+
+class IPv4Address(_BaseV4, _BaseAddress):
+    __slots__ = ("_ip", "__weakref__")
+    def __init__(self, address: object) -> None: ...
+    @property
+    def is_global(self) -> bool: ...
+    @property
+    def is_link_local(self) -> bool: ...
+    @property
+    def is_loopback(self) -> bool: ...
+    @property
+    def is_multicast(self) -> bool: ...
+    @property
+    def is_private(self) -> bool: ...
+    @property
+    def is_reserved(self) -> bool: ...
+    @property
+    def is_unspecified(self) -> bool: ...
+    @property
+    def packed(self) -> bytes: ...
+    if sys.version_info >= (3, 13):
+        @property
+        def ipv6_mapped(self) -> IPv6Address: ...
+
+class IPv4Network(_BaseV4, _BaseNetwork[IPv4Address]):
+    def __init__(self, address: object, strict: bool = True) -> None: ...
+
+class IPv4Interface(IPv4Address):
+    netmask: IPv4Address
+    network: IPv4Network
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    @property
+    def hostmask(self) -> IPv4Address: ...
+    @property
+    def ip(self) -> IPv4Address: ...
+    @property
+    def with_hostmask(self) -> str: ...
+    @property
+    def with_netmask(self) -> str: ...
+    @property
+    def with_prefixlen(self) -> str: ...
+
+class _BaseV6:
+    __slots__ = ()
+    if sys.version_info >= (3, 14):
+        version: Final = 6
+        max_prefixlen: Final = 128
+    else:
+        @property
+        def version(self) -> Literal[6]: ...
+        @property
+        def max_prefixlen(self) -> Literal[128]: ...
+
+class IPv6Address(_BaseV6, _BaseAddress):
+    __slots__ = ("_ip", "_scope_id", "__weakref__")
+    def __init__(self, address: object) -> None: ...
+    @property
+    def is_global(self) -> bool: ...
+    @property
+    def is_link_local(self) -> bool: ...
+    @property
+    def is_loopback(self) -> bool: ...
+    @property
+    def is_multicast(self) -> bool: ...
+    @property
+    def is_private(self) -> bool: ...
+    @property
+    def is_reserved(self) -> bool: ...
+    @property
+    def is_unspecified(self) -> bool: ...
+    @property
+    def packed(self) -> bytes: ...
+    @property
+    def ipv4_mapped(self) -> IPv4Address | None: ...
+    @property
+    def is_site_local(self) -> bool: ...
+    @property
+    def sixtofour(self) -> IPv4Address | None: ...
+    @property
+    def teredo(self) -> tuple[IPv4Address, IPv4Address] | None: ...
+    @property
+    def scope_id(self) -> str | None: ...
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+
+class IPv6Network(_BaseV6, _BaseNetwork[IPv6Address]):
+    def __init__(self, address: object, strict: bool = True) -> None: ...
+    @property
+    def is_site_local(self) -> bool: ...
+
+class IPv6Interface(IPv6Address):
+    netmask: IPv6Address
+    network: IPv6Network
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    @property
+    def hostmask(self) -> IPv6Address: ...
+    @property
+    def ip(self) -> IPv6Address: ...
+    @property
+    def with_hostmask(self) -> str: ...
+    @property
+    def with_netmask(self) -> str: ...
+    @property
+    def with_prefixlen(self) -> str: ...
+
+def v4_int_to_packed(address: int) -> bytes: ...
+def v6_int_to_packed(address: int) -> bytes: ...
+
+# Third overload is technically incorrect, but convenient when first and last are return values of ip_address()
+@overload
+def summarize_address_range(first: IPv4Address, last: IPv4Address) -> Iterator[IPv4Network]: ...
+@overload
+def summarize_address_range(first: IPv6Address, last: IPv6Address) -> Iterator[IPv6Network]: ...
+@overload
+def summarize_address_range(
+    first: IPv4Address | IPv6Address, last: IPv4Address | IPv6Address
+) -> Iterator[IPv4Network] | Iterator[IPv6Network]: ...
+
+def collapse_addresses(addresses: Iterable[_N]) -> Iterator[_N]: ...
+
+@overload
+def get_mixed_type_key(obj: _A) -> tuple[int, _A]: ...
+@overload
+def get_mixed_type_key(obj: IPv4Network) -> tuple[int, IPv4Address, IPv4Address]: ...
+@overload
+def get_mixed_type_key(obj: IPv6Network) -> tuple[int, IPv6Address, IPv6Address]: ...
+
+class AddressValueError(ValueError): ...
+class NetmaskValueError(ValueError): ...

package/analyzers/project-map-python/typeshed/stdlib/itertools.pyi

@@ -0,0 +1,376 @@
+import sys
+from _typeshed import MaybeNone
+from collections.abc import Callable, Iterable, Iterator
+from types import GenericAlias
+from typing import Any, Generic, Literal, SupportsComplex, SupportsFloat, SupportsIndex, SupportsInt, TypeAlias, TypeVar, overload
+from typing_extensions import Self, disjoint_base
+
+_T = TypeVar("_T")
+_S = TypeVar("_S")
+_N = TypeVar("_N", int, float, SupportsFloat, SupportsInt, SupportsIndex, SupportsComplex)
+_T_co = TypeVar("_T_co", covariant=True)
+_S_co = TypeVar("_S_co", covariant=True)
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+_T3 = TypeVar("_T3")
+_T4 = TypeVar("_T4")
+_T5 = TypeVar("_T5")
+_T6 = TypeVar("_T6")
+_T7 = TypeVar("_T7")
+_T8 = TypeVar("_T8")
+_T9 = TypeVar("_T9")
+_T10 = TypeVar("_T10")
+
+_Step: TypeAlias = SupportsFloat | SupportsInt | SupportsIndex | SupportsComplex
+
+_Predicate: TypeAlias = Callable[[_T], object]
+
+# Technically count can take anything that implements a number protocol and has an add method
+# but we can't enforce the add method
+@disjoint_base
+class count(Generic[_N]):
+    @overload
+    def __new__(cls) -> count[int]: ...
+    @overload
+    def __new__(cls, start: _N, step: _Step = 1) -> count[_N]: ...
+    @overload
+    def __new__(cls, *, step: _N) -> count[_N]: ...
+
+    def __next__(self) -> _N: ...
+    def __iter__(self) -> Self: ...
+
+@disjoint_base
+class cycle(Generic[_T]):
+    def __new__(cls, iterable: Iterable[_T], /) -> Self: ...
+    def __next__(self) -> _T: ...
+    def __iter__(self) -> Self: ...
+
+@disjoint_base
+class repeat(Generic[_T]):
+    @overload
+    def __new__(cls, object: _T) -> Self: ...
+    @overload
+    def __new__(cls, object: _T, times: int) -> Self: ...
+
+    def __next__(self) -> _T: ...
+    def __iter__(self) -> Self: ...
+    def __length_hint__(self) -> int: ...
+
+@disjoint_base
+class accumulate(Generic[_T]):
+    @overload
+    def __new__(cls, iterable: Iterable[_T], func: None = None, *, initial: _T | None = None) -> Self: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_S], func: Callable[[_T, _S], _T], *, initial: _T | None = None) -> Self: ...
+
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> _T: ...
+
+@disjoint_base
+class chain(Generic[_T]):
+    def __new__(cls, *iterables: Iterable[_T]) -> Self: ...
+    def __next__(self) -> _T: ...
+    def __iter__(self) -> Self: ...
+    @classmethod
+    # We use type[Any] and not type[_S] to not lose the type inference from __iterable
+    def from_iterable(cls: type[Any], iterable: Iterable[Iterable[_S]], /) -> chain[_S]: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+@disjoint_base
+class compress(Generic[_T]):
+    def __new__(cls, data: Iterable[_T], selectors: Iterable[Any]) -> Self: ...
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> _T: ...
+
+@disjoint_base
+class dropwhile(Generic[_T]):
+    def __new__(cls, predicate: _Predicate[_T], iterable: Iterable[_T], /) -> Self: ...
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> _T: ...
+
+@disjoint_base
+class filterfalse(Generic[_T]):
+    def __new__(cls, function: _Predicate[_T] | None, iterable: Iterable[_T], /) -> Self: ...
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> _T: ...
+
+@disjoint_base
+class groupby(Generic[_T_co, _S_co]):
+    @overload
+    def __new__(cls, iterable: Iterable[_T1], key: None = None) -> groupby[_T1, _T1]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T1], key: Callable[[_T1], _T2]) -> groupby[_T2, _T1]: ...
+
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> tuple[_T_co, Iterator[_S_co]]: ...
+
+@disjoint_base
+class islice(Generic[_T]):
+    @overload
+    def __new__(cls, iterable: Iterable[_T], stop: int | None, /) -> Self: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], start: int | None, stop: int | None, step: int | None = 1, /) -> Self: ...
+
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> _T: ...
+
+@disjoint_base
+class starmap(Generic[_T_co]):
+    def __new__(cls, function: Callable[..., _T], iterable: Iterable[Iterable[Any]], /) -> starmap[_T]: ...
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> _T_co: ...
+
+@disjoint_base
+class takewhile(Generic[_T]):
+    def __new__(cls, predicate: _Predicate[_T], iterable: Iterable[_T], /) -> Self: ...
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> _T: ...
+
+def tee(iterable: Iterable[_T], n: int = 2, /) -> tuple[Iterator[_T], ...]: ...
+
+@disjoint_base
+class zip_longest(Generic[_T_co]):
+    # one iterable (fillvalue doesn't matter)
+    @overload
+    def __new__(cls, iter1: Iterable[_T1], /, *, fillvalue: object = None) -> zip_longest[tuple[_T1]]: ...
+    # two iterables
+    @overload
+    # In the overloads without fillvalue, all of the tuple members could theoretically be None,
+    # but we return Any instead to avoid false positives for code where we know one of the iterables
+    # is longer.
+    def __new__(cls, iter1: Iterable[_T1], iter2: Iterable[_T2], /) -> zip_longest[tuple[_T1 | MaybeNone, _T2 | MaybeNone]]: ...
+    @overload
+    def __new__(
+        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], /, *, fillvalue: _T
+    ) -> zip_longest[tuple[_T1 | _T, _T2 | _T]]: ...
+    # three iterables
+    @overload
+    def __new__(
+        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], /
+    ) -> zip_longest[tuple[_T1 | MaybeNone, _T2 | MaybeNone, _T3 | MaybeNone]]: ...
+    @overload
+    def __new__(
+        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], /, *, fillvalue: _T
+    ) -> zip_longest[tuple[_T1 | _T, _T2 | _T, _T3 | _T]]: ...
+    # four iterables
+    @overload
+    def __new__(
+        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], /
+    ) -> zip_longest[tuple[_T1 | MaybeNone, _T2 | MaybeNone, _T3 | MaybeNone, _T4 | MaybeNone]]: ...
+    @overload
+    def __new__(
+        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], /, *, fillvalue: _T
+    ) -> zip_longest[tuple[_T1 | _T, _T2 | _T, _T3 | _T, _T4 | _T]]: ...
+    # five iterables
+    @overload
+    def __new__(
+        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5], /
+    ) -> zip_longest[tuple[_T1 | MaybeNone, _T2 | MaybeNone, _T3 | MaybeNone, _T4 | MaybeNone, _T5 | MaybeNone]]: ...
+    @overload
+    def __new__(
+        cls,
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        /,
+        *,
+        fillvalue: _T,
+    ) -> zip_longest[tuple[_T1 | _T, _T2 | _T, _T3 | _T, _T4 | _T, _T5 | _T]]: ...
+    # six or more iterables
+    @overload
+    def __new__(
+        cls,
+        iter1: Iterable[_T],
+        iter2: Iterable[_T],
+        iter3: Iterable[_T],
+        iter4: Iterable[_T],
+        iter5: Iterable[_T],
+        iter6: Iterable[_T],
+        /,
+        *iterables: Iterable[_T],
+    ) -> zip_longest[tuple[_T | MaybeNone, ...]]: ...
+    @overload
+    def __new__(
+        cls,
+        iter1: Iterable[_T],
+        iter2: Iterable[_T],
+        iter3: Iterable[_T],
+        iter4: Iterable[_T],
+        iter5: Iterable[_T],
+        iter6: Iterable[_T],
+        /,
+        *iterables: Iterable[_T],
+        fillvalue: _T,
+    ) -> zip_longest[tuple[_T, ...]]: ...
+
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> _T_co: ...
+
+@disjoint_base
+class product(Generic[_T_co]):
+    @overload
+    def __new__(cls, iter1: Iterable[_T1], /) -> product[tuple[_T1]]: ...
+    @overload
+    def __new__(cls, iter1: Iterable[_T1], iter2: Iterable[_T2], /) -> product[tuple[_T1, _T2]]: ...
+    @overload
+    def __new__(cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], /) -> product[tuple[_T1, _T2, _T3]]: ...
+    @overload
+    def __new__(
+        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], /
+    ) -> product[tuple[_T1, _T2, _T3, _T4]]: ...
+    @overload
+    def __new__(
+        cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5], /
+    ) -> product[tuple[_T1, _T2, _T3, _T4, _T5]]: ...
+    @overload
+    def __new__(
+        cls,
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        iter6: Iterable[_T6],
+        /,
+    ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6]]: ...
+    @overload
+    def __new__(
+        cls,
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        iter6: Iterable[_T6],
+        iter7: Iterable[_T7],
+        /,
+    ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6, _T7]]: ...
+    @overload
+    def __new__(
+        cls,
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        iter6: Iterable[_T6],
+        iter7: Iterable[_T7],
+        iter8: Iterable[_T8],
+        /,
+    ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8]]: ...
+    @overload
+    def __new__(
+        cls,
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        iter6: Iterable[_T6],
+        iter7: Iterable[_T7],
+        iter8: Iterable[_T8],
+        iter9: Iterable[_T9],
+        /,
+    ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9]]: ...
+    @overload
+    def __new__(
+        cls,
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        iter6: Iterable[_T6],
+        iter7: Iterable[_T7],
+        iter8: Iterable[_T8],
+        iter9: Iterable[_T9],
+        iter10: Iterable[_T10],
+        /,
+    ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10]]: ...
+    @overload
+    def __new__(cls, *iterables: Iterable[_T1], repeat: int = 1) -> product[tuple[_T1, ...]]: ...
+
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> _T_co: ...
+
+@disjoint_base
+class permutations(Generic[_T_co]):
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> permutations[tuple[_T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[3]) -> permutations[tuple[_T, _T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[4]) -> permutations[tuple[_T, _T, _T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[5]) -> permutations[tuple[_T, _T, _T, _T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: int | None = None) -> permutations[tuple[_T, ...]]: ...
+
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> _T_co: ...
+
+@disjoint_base
+class combinations(Generic[_T_co]):
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> combinations[tuple[_T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[3]) -> combinations[tuple[_T, _T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[4]) -> combinations[tuple[_T, _T, _T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[5]) -> combinations[tuple[_T, _T, _T, _T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: int) -> combinations[tuple[_T, ...]]: ...
+
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> _T_co: ...
+
+@disjoint_base
+class combinations_with_replacement(Generic[_T_co]):
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> combinations_with_replacement[tuple[_T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[3]) -> combinations_with_replacement[tuple[_T, _T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[4]) -> combinations_with_replacement[tuple[_T, _T, _T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: Literal[5]) -> combinations_with_replacement[tuple[_T, _T, _T, _T, _T]]: ...
+    @overload
+    def __new__(cls, iterable: Iterable[_T], r: int) -> combinations_with_replacement[tuple[_T, ...]]: ...
+
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> _T_co: ...
+
+@disjoint_base
+class pairwise(Generic[_T_co]):
+    def __new__(cls, iterable: Iterable[_T], /) -> pairwise[tuple[_T, _T]]: ...
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> _T_co: ...
+
+if sys.version_info >= (3, 12):
+    @disjoint_base
+    class batched(Generic[_T_co]):
+        if sys.version_info >= (3, 13):
+            @overload
+            def __new__(cls, iterable: Iterable[_T], n: Literal[1], *, strict: Literal[True]) -> batched[tuple[_T]]: ...
+            @overload
+            def __new__(cls, iterable: Iterable[_T], n: Literal[2], *, strict: Literal[True]) -> batched[tuple[_T, _T]]: ...
+            @overload
+            def __new__(cls, iterable: Iterable[_T], n: Literal[3], *, strict: Literal[True]) -> batched[tuple[_T, _T, _T]]: ...
+            @overload
+            def __new__(
+                cls, iterable: Iterable[_T], n: Literal[4], *, strict: Literal[True]
+            ) -> batched[tuple[_T, _T, _T, _T]]: ...
+            @overload
+            def __new__(
+                cls, iterable: Iterable[_T], n: Literal[5], *, strict: Literal[True]
+            ) -> batched[tuple[_T, _T, _T, _T, _T]]: ...
+            @overload
+            def __new__(cls, iterable: Iterable[_T], n: int, *, strict: bool = False) -> batched[tuple[_T, ...]]: ...
+        else:
+            def __new__(cls, iterable: Iterable[_T], n: int) -> batched[tuple[_T, ...]]: ...
+
+        def __iter__(self) -> Self: ...
+        def __next__(self) -> _T_co: ...