layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/asyncio/tools.pyi

@@ -0,0 +1,51 @@
+import sys
+from collections.abc import Iterable
+from enum import Enum
+from typing import NamedTuple, SupportsIndex, type_check_only
+
+@type_check_only
+class _AwaitedInfo(NamedTuple):  # AwaitedInfo_Type from _remote_debugging
+    thread_id: int
+    awaited_by: list[_TaskInfo]
+
+@type_check_only
+class _TaskInfo(NamedTuple):  # TaskInfo_Type from _remote_debugging
+    task_id: int
+    task_name: str
+    coroutine_stack: list[_CoroInfo]
+    awaited_by: list[_CoroInfo]
+
+@type_check_only
+class _CoroInfo(NamedTuple):  # CoroInfo_Type from _remote_debugging
+    call_stack: list[_FrameInfo]
+    task_name: int | str
+
+@type_check_only
+class _FrameInfo(NamedTuple):  # FrameInfo_Type from _remote_debugging
+    filename: str
+    lineno: int
+    funcname: str
+
+class NodeType(Enum):
+    COROUTINE = 1
+    TASK = 2
+
+class CycleFoundException(Exception):
+    cycles: list[list[int]]
+    id2name: dict[int, str]
+    def __init__(self, cycles: list[list[int]], id2name: dict[int, str]) -> None: ...
+
+def get_all_awaited_by(pid: SupportsIndex) -> list[_AwaitedInfo]: ...
+def build_async_tree(result: Iterable[_AwaitedInfo], task_emoji: str = "(T)", cor_emoji: str = "") -> list[list[str]]: ...
+def build_task_table(result: Iterable[_AwaitedInfo]) -> list[list[int | str]]: ...
+
+if sys.version_info >= (3, 14):
+    def exit_with_permission_help_text() -> None: ...
+
+if sys.version_info >= (3, 15):
+    def display_awaited_by_tasks_table(pid: SupportsIndex, retries: SupportsIndex = 3) -> None: ...
+    def display_awaited_by_tasks_tree(pid: SupportsIndex, retries: SupportsIndex = 3) -> None: ...
+
+else:
+    def display_awaited_by_tasks_table(pid: SupportsIndex) -> None: ...
+    def display_awaited_by_tasks_tree(pid: SupportsIndex) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/asyncio/transports.pyi

@@ -0,0 +1,57 @@
+from asyncio.events import AbstractEventLoop
+from asyncio.protocols import BaseProtocol
+from collections.abc import Iterable, Mapping
+from socket import _Address
+from typing import Any
+
+# Keep asyncio.__all__ updated with any changes to __all__ here
+__all__ = ("BaseTransport", "ReadTransport", "WriteTransport", "Transport", "DatagramTransport", "SubprocessTransport")
+
+class BaseTransport:
+    __slots__ = ("_extra",)
+    def __init__(self, extra: Mapping[str, Any] | None = None) -> None: ...
+    def get_extra_info(self, name: str, default: Any = None) -> Any: ...
+    def is_closing(self) -> bool: ...
+    def close(self) -> None: ...
+    def set_protocol(self, protocol: BaseProtocol) -> None: ...
+    def get_protocol(self) -> BaseProtocol: ...
+
+class ReadTransport(BaseTransport):
+    __slots__ = ()
+    def is_reading(self) -> bool: ...
+    def pause_reading(self) -> None: ...
+    def resume_reading(self) -> None: ...
+
+class WriteTransport(BaseTransport):
+    __slots__ = ()
+    def set_write_buffer_limits(self, high: int | None = None, low: int | None = None) -> None: ...
+    def get_write_buffer_size(self) -> int: ...
+    def get_write_buffer_limits(self) -> tuple[int, int]: ...
+    def write(self, data: bytes | bytearray | memoryview[Any]) -> None: ...  # any memoryview format or shape
+    def writelines(
+        self, list_of_data: Iterable[bytes | bytearray | memoryview[Any]]
+    ) -> None: ...  # any memoryview format or shape
+    def write_eof(self) -> None: ...
+    def can_write_eof(self) -> bool: ...
+    def abort(self) -> None: ...
+
+class Transport(ReadTransport, WriteTransport):
+    __slots__ = ()
+
+class DatagramTransport(BaseTransport):
+    __slots__ = ()
+    def sendto(self, data: bytes | bytearray | memoryview, addr: _Address | None = None) -> None: ...
+    def abort(self) -> None: ...
+
+class SubprocessTransport(BaseTransport):
+    __slots__ = ()
+    def get_pid(self) -> int: ...
+    def get_returncode(self) -> int | None: ...
+    def get_pipe_transport(self, fd: int) -> BaseTransport | None: ...
+    def send_signal(self, signal: int) -> None: ...
+    def terminate(self) -> None: ...
+    def kill(self) -> None: ...
+
+class _FlowControlMixin(Transport):
+    __slots__ = ("_loop", "_protocol_paused", "_high_water", "_low_water")
+    def __init__(self, extra: Mapping[str, Any] | None = None, loop: AbstractEventLoop | None = None) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/asyncio/trsock.pyi

@@ -0,0 +1,137 @@
+import socket
+import sys
+from _typeshed import ReadableBuffer
+from builtins import type as Type  # alias to avoid name clashes with property named "type"
+from collections.abc import Iterable
+from types import TracebackType
+from typing import Any, BinaryIO, NoReturn, TypeAlias, overload
+from typing_extensions import deprecated
+
+# These are based in socket, maybe move them out into _typeshed.pyi or such
+_Address: TypeAlias = socket._Address
+_RetAddress: TypeAlias = Any
+_WriteBuffer: TypeAlias = bytearray | memoryview
+_CMSG: TypeAlias = tuple[int, int, bytes]
+
+class TransportSocket:
+    __slots__ = ("_sock",)
+    def __init__(self, sock: socket.socket) -> None: ...
+    @property
+    def family(self) -> int: ...
+    @property
+    def type(self) -> int: ...
+    @property
+    def proto(self) -> int: ...
+    def __getstate__(self) -> NoReturn: ...
+    def fileno(self) -> int: ...
+    def dup(self) -> socket.socket: ...
+    def get_inheritable(self) -> bool: ...
+    def shutdown(self, how: int) -> None: ...
+
+    @overload
+    def getsockopt(self, level: int, optname: int) -> int: ...
+    @overload
+    def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ...
+
+    @overload
+    def setsockopt(self, level: int, optname: int, value: int | ReadableBuffer) -> None: ...
+    @overload
+    def setsockopt(self, level: int, optname: int, value: None, optlen: int) -> None: ...
+
+    def getpeername(self) -> _RetAddress: ...
+    def getsockname(self) -> _RetAddress: ...
+    def getsockbyname(self) -> NoReturn: ...  # This method doesn't exist on socket, yet is passed through?
+    def settimeout(self, value: float | None) -> None: ...
+    def gettimeout(self) -> float | None: ...
+    def setblocking(self, flag: bool) -> None: ...
+    if sys.version_info < (3, 11):
+        def _na(self, what: str) -> None: ...
+        @deprecated("Removed in Python 3.11")
+        def accept(self) -> tuple[socket.socket, _RetAddress]: ...
+        @deprecated("Removed in Python 3.11")
+        def connect(self, address: _Address) -> None: ...
+        @deprecated("Removed in Python 3.11")
+        def connect_ex(self, address: _Address) -> int: ...
+        @deprecated("Removed in Python 3.11")
+        def bind(self, address: _Address) -> None: ...
+
+        if sys.platform == "win32":
+            @deprecated("Removed in Python 3.11")
+            def ioctl(self, control: int, option: int | tuple[int, int, int] | bool) -> None: ...
+        else:
+            @deprecated("Removed in Python 3.11")
+            def ioctl(self, control: int, option: int | tuple[int, int, int] | bool) -> NoReturn: ...
+
+        @deprecated("Removed in Python 3.11")
+        def listen(self, backlog: int = ..., /) -> None: ...
+        @deprecated("Removed in Python 3.11")
+        def makefile(self) -> BinaryIO: ...
+        @deprecated("Removed in Python 3.11")
+        def sendfile(self, file: BinaryIO, offset: int = 0, count: int | None = None) -> int: ...
+        @deprecated("Removed in Python 3.11")
+        def close(self) -> None: ...
+        @deprecated("Removed in Python 3.11")
+        def detach(self) -> int: ...
+
+        if sys.platform == "linux":
+            @deprecated("Removed in Python 3.11")
+            def sendmsg_afalg(
+                self, msg: Iterable[ReadableBuffer] = ..., *, op: int, iv: Any = ..., assoclen: int = ..., flags: int = 0
+            ) -> int: ...
+        else:
+            @deprecated("Removed in Python 3.11.")
+            def sendmsg_afalg(
+                self, msg: Iterable[ReadableBuffer] = ..., *, op: int, iv: Any = ..., assoclen: int = ..., flags: int = 0
+            ) -> NoReturn: ...
+
+        @deprecated("Removed in Python 3.11.")
+        def sendmsg(
+            self,
+            buffers: Iterable[ReadableBuffer],
+            ancdata: Iterable[_CMSG] = ...,
+            flags: int = 0,
+            address: _Address | None = None,
+            /,
+        ) -> int: ...
+
+        @overload
+        @deprecated("Removed in Python 3.11.")
+        def sendto(self, data: ReadableBuffer, address: _Address) -> int: ...
+        @overload
+        @deprecated("Removed in Python 3.11.")
+        def sendto(self, data: ReadableBuffer, flags: int, address: _Address) -> int: ...
+
+        @deprecated("Removed in Python 3.11.")
+        def send(self, data: ReadableBuffer, flags: int = 0) -> int: ...
+        @deprecated("Removed in Python 3.11.")
+        def sendall(self, data: ReadableBuffer, flags: int = 0) -> None: ...
+        @deprecated("Removed in Python 3.11.")
+        def set_inheritable(self, inheritable: bool) -> None: ...
+
+        if sys.platform == "win32":
+            @deprecated("Removed in Python 3.11.")
+            def share(self, process_id: int) -> bytes: ...
+        else:
+            @deprecated("Removed in Python 3.11.")
+            def share(self, process_id: int) -> NoReturn: ...
+
+        @deprecated("Removed in Python 3.11.")
+        def recv_into(self, buffer: _WriteBuffer, nbytes: int = 0, flags: int = 0) -> int: ...
+        @deprecated("Removed in Python 3.11.")
+        def recvfrom_into(self, buffer: _WriteBuffer, nbytes: int = 0, flags: int = 0) -> tuple[int, _RetAddress]: ...
+        @deprecated("Removed in Python 3.11.")
+        def recvmsg_into(
+            self, buffers: Iterable[_WriteBuffer], ancbufsize: int = 0, flags: int = 0, /
+        ) -> tuple[int, list[_CMSG], int, Any]: ...
+        @deprecated("Removed in Python 3.11.")
+        def recvmsg(self, bufsize: int, ancbufsize: int = 0, flags: int = 0, /) -> tuple[bytes, list[_CMSG], int, Any]: ...
+        @deprecated("Removed in Python 3.11.")
+        def recvfrom(self, bufsize: int, flags: int = 0) -> tuple[bytes, _RetAddress]: ...
+        @deprecated("Removed in Python 3.11.")
+        def recv(self, bufsize: int, flags: int = 0) -> bytes: ...
+        @deprecated("Removed in Python 3.11.")
+        def __enter__(self) -> socket.socket: ...
+        @deprecated("Removed in Python 3.11.")
+        def __exit__(
+            self, exc_type: Type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+        ) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/asyncio/unix_events.pyi

@@ -0,0 +1,277 @@
+import sys
+import types
+from _typeshed import StrPath
+from abc import ABCMeta, abstractmethod
+from collections.abc import Callable
+from socket import socket
+from typing import Literal
+from typing_extensions import Self, TypeVarTuple, Unpack, deprecated
+
+from . import events
+from .base_events import Server, _ProtocolFactory, _SSLContext
+from .selector_events import BaseSelectorEventLoop
+
+_Ts = TypeVarTuple("_Ts")
+
+# Keep asyncio.__all__ updated with any changes to __all__ here
+if sys.platform != "win32":
+    if sys.version_info >= (3, 14):
+        __all__ = ("SelectorEventLoop", "EventLoop")
+    elif sys.version_info >= (3, 13):
+        # Adds EventLoop
+        __all__ = (
+            "SelectorEventLoop",
+            "AbstractChildWatcher",
+            "SafeChildWatcher",
+            "FastChildWatcher",
+            "PidfdChildWatcher",
+            "MultiLoopChildWatcher",
+            "ThreadedChildWatcher",
+            "DefaultEventLoopPolicy",
+            "EventLoop",
+        )
+    else:
+        # adds PidfdChildWatcher
+        __all__ = (
+            "SelectorEventLoop",
+            "AbstractChildWatcher",
+            "SafeChildWatcher",
+            "FastChildWatcher",
+            "PidfdChildWatcher",
+            "MultiLoopChildWatcher",
+            "ThreadedChildWatcher",
+            "DefaultEventLoopPolicy",
+        )
+
+# This is also technically not available on Win,
+# but other parts of typeshed need this definition.
+# So, it is special cased.
+if sys.version_info < (3, 14):
+    if sys.version_info >= (3, 12):
+        @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
+        class AbstractChildWatcher:
+            @abstractmethod
+            def add_child_handler(
+                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+            ) -> None: ...
+            @abstractmethod
+            def remove_child_handler(self, pid: int) -> bool: ...
+            @abstractmethod
+            def attach_loop(self, loop: events.AbstractEventLoop | None) -> None: ...
+            @abstractmethod
+            def close(self) -> None: ...
+            @abstractmethod
+            def __enter__(self) -> Self: ...
+            @abstractmethod
+            def __exit__(
+                self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
+            ) -> None: ...
+            @abstractmethod
+            def is_active(self) -> bool: ...
+
+    else:
+        class AbstractChildWatcher:
+            @abstractmethod
+            def add_child_handler(
+                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+            ) -> None: ...
+            @abstractmethod
+            def remove_child_handler(self, pid: int) -> bool: ...
+            @abstractmethod
+            def attach_loop(self, loop: events.AbstractEventLoop | None) -> None: ...
+            @abstractmethod
+            def close(self) -> None: ...
+            @abstractmethod
+            def __enter__(self) -> Self: ...
+            @abstractmethod
+            def __exit__(
+                self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
+            ) -> None: ...
+            @abstractmethod
+            def is_active(self) -> bool: ...
+
+if sys.platform != "win32":
+    if sys.version_info < (3, 14):
+        if sys.version_info >= (3, 12):
+            # Doesn't actually have ABCMeta metaclass at runtime, but mypy complains if we don't have it in the stub.
+            # See discussion in #7412
+            @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
+            class BaseChildWatcher(AbstractChildWatcher, metaclass=ABCMeta):
+                def close(self) -> None: ...
+                def is_active(self) -> bool: ...
+                def attach_loop(self, loop: events.AbstractEventLoop | None) -> None: ...
+
+            @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
+            class SafeChildWatcher(BaseChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+
+            @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
+            class FastChildWatcher(BaseChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+
+        else:
+            # Doesn't actually have ABCMeta metaclass at runtime, but mypy complains if we don't have it in the stub.
+            # See discussion in #7412
+            class BaseChildWatcher(AbstractChildWatcher, metaclass=ABCMeta):
+                def close(self) -> None: ...
+                def is_active(self) -> bool: ...
+                def attach_loop(self, loop: events.AbstractEventLoop | None) -> None: ...
+
+            class SafeChildWatcher(BaseChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+
+            class FastChildWatcher(BaseChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+
+    class _UnixSelectorEventLoop(BaseSelectorEventLoop):
+        if sys.version_info >= (3, 13):
+            async def create_unix_server(
+                self,
+                protocol_factory: _ProtocolFactory,
+                path: StrPath | None = None,
+                *,
+                sock: socket | None = None,
+                backlog: int = 100,
+                ssl: _SSLContext = None,
+                ssl_handshake_timeout: float | None = None,
+                ssl_shutdown_timeout: float | None = None,
+                start_serving: bool = True,
+                cleanup_socket: bool = True,
+            ) -> Server: ...
+
+    if sys.version_info >= (3, 14):
+        class _UnixDefaultEventLoopPolicy(events._BaseDefaultEventLoopPolicy): ...
+    else:
+        class _UnixDefaultEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
+            if sys.version_info >= (3, 12):
+                @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
+                def get_child_watcher(self) -> AbstractChildWatcher: ...
+                @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
+                def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
+            else:
+                def get_child_watcher(self) -> AbstractChildWatcher: ...
+                def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
+
+    SelectorEventLoop = _UnixSelectorEventLoop
+
+    if sys.version_info >= (3, 14):
+        _DefaultEventLoopPolicy = _UnixDefaultEventLoopPolicy
+    else:
+        DefaultEventLoopPolicy = _UnixDefaultEventLoopPolicy
+
+    if sys.version_info >= (3, 13):
+        EventLoop = SelectorEventLoop
+
+    if sys.version_info < (3, 14):
+        if sys.version_info >= (3, 12):
+            @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
+            class MultiLoopChildWatcher(AbstractChildWatcher):
+                def is_active(self) -> bool: ...
+                def close(self) -> None: ...
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+                def attach_loop(self, loop: events.AbstractEventLoop | None) -> None: ...
+
+            @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
+            class ThreadedChildWatcher(AbstractChildWatcher):
+                def is_active(self) -> Literal[True]: ...
+                def close(self) -> None: ...
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+                ) -> None: ...
+                def __del__(self) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+                def attach_loop(self, loop: events.AbstractEventLoop | None) -> None: ...
+
+            @deprecated("Deprecated since Python 3.12; removed in Python 3.14.")
+            class PidfdChildWatcher(AbstractChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+                ) -> None: ...
+                def is_active(self) -> bool: ...
+                def close(self) -> None: ...
+                def attach_loop(self, loop: events.AbstractEventLoop | None) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+
+        else:
+            class MultiLoopChildWatcher(AbstractChildWatcher):
+                def is_active(self) -> bool: ...
+                def close(self) -> None: ...
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+                def attach_loop(self, loop: events.AbstractEventLoop | None) -> None: ...
+
+            class ThreadedChildWatcher(AbstractChildWatcher):
+                def is_active(self) -> Literal[True]: ...
+                def close(self) -> None: ...
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+                ) -> None: ...
+                def __del__(self) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+                def attach_loop(self, loop: events.AbstractEventLoop | None) -> None: ...
+
+            class PidfdChildWatcher(AbstractChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+                ) -> None: ...
+                def is_active(self) -> bool: ...
+                def close(self) -> None: ...
+                def attach_loop(self, loop: events.AbstractEventLoop | None) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...

package/analyzers/project-map-python/typeshed/stdlib/asyncio/windows_events.pyi

@@ -0,0 +1,121 @@
+import socket
+import sys
+from _typeshed import Incomplete, ReadableBuffer, WriteableBuffer
+from collections.abc import Callable
+from typing import IO, Any, ClassVar, Final, NoReturn
+
+from . import events, futures, proactor_events, selector_events, streams, windows_utils
+
+# Keep asyncio.__all__ updated with any changes to __all__ here
+if sys.platform == "win32":
+    if sys.version_info >= (3, 14):
+        __all__ = (
+            "SelectorEventLoop",
+            "ProactorEventLoop",
+            "IocpProactor",
+            "_DefaultEventLoopPolicy",
+            "_WindowsSelectorEventLoopPolicy",
+            "_WindowsProactorEventLoopPolicy",
+            "EventLoop",
+        )
+    elif sys.version_info >= (3, 13):
+        # 3.13 added `EventLoop`.
+        __all__ = (
+            "SelectorEventLoop",
+            "ProactorEventLoop",
+            "IocpProactor",
+            "DefaultEventLoopPolicy",
+            "WindowsSelectorEventLoopPolicy",
+            "WindowsProactorEventLoopPolicy",
+            "EventLoop",
+        )
+    else:
+        __all__ = (
+            "SelectorEventLoop",
+            "ProactorEventLoop",
+            "IocpProactor",
+            "DefaultEventLoopPolicy",
+            "WindowsSelectorEventLoopPolicy",
+            "WindowsProactorEventLoopPolicy",
+        )
+
+    NULL: Final = 0
+    INFINITE: Final = 0xFFFFFFFF
+    ERROR_CONNECTION_REFUSED: Final = 1225
+    ERROR_CONNECTION_ABORTED: Final = 1236
+    CONNECT_PIPE_INIT_DELAY: float
+    CONNECT_PIPE_MAX_DELAY: float
+
+    class PipeServer:
+        def __init__(self, address: str) -> None: ...
+        def __del__(self) -> None: ...
+        def closed(self) -> bool: ...
+        def close(self) -> None: ...
+
+    class _WindowsSelectorEventLoop(selector_events.BaseSelectorEventLoop): ...
+
+    class ProactorEventLoop(proactor_events.BaseProactorEventLoop):
+        def __init__(self, proactor: IocpProactor | None = None) -> None: ...
+        async def create_pipe_connection(
+            self, protocol_factory: Callable[[], streams.StreamReaderProtocol], address: str
+        ) -> tuple[proactor_events._ProactorDuplexPipeTransport, streams.StreamReaderProtocol]: ...
+        async def start_serving_pipe(
+            self, protocol_factory: Callable[[], streams.StreamReaderProtocol], address: str
+        ) -> list[PipeServer]: ...
+
+    class IocpProactor:
+        def __init__(self, concurrency: int = 0xFFFFFFFF) -> None: ...
+        def __del__(self) -> None: ...
+        def set_loop(self, loop: events.AbstractEventLoop) -> None: ...
+        def select(self, timeout: int | None = None) -> list[futures.Future[Any]]: ...
+        def recv(self, conn: socket.socket, nbytes: int, flags: int = 0) -> futures.Future[bytes]: ...
+        def recv_into(self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0) -> futures.Future[Any]: ...
+        def recvfrom(
+            self, conn: socket.socket, nbytes: int, flags: int = 0
+        ) -> futures.Future[tuple[bytes, socket._RetAddress]]: ...
+        def sendto(
+            self, conn: socket.socket, buf: ReadableBuffer, flags: int = 0, addr: socket._Address | None = None
+        ) -> futures.Future[int]: ...
+        def send(self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0) -> futures.Future[Any]: ...
+        def accept(self, listener: socket.socket) -> futures.Future[Any]: ...
+        def connect(
+            self,
+            conn: socket.socket,
+            address: tuple[Incomplete, Incomplete] | tuple[Incomplete, Incomplete, Incomplete, Incomplete],
+        ) -> futures.Future[Any]: ...
+        def sendfile(self, sock: socket.socket, file: IO[bytes], offset: int, count: int) -> futures.Future[Any]: ...
+        def accept_pipe(self, pipe: socket.socket) -> futures.Future[Any]: ...
+        async def connect_pipe(self, address: str) -> windows_utils.PipeHandle: ...
+        def wait_for_handle(self, handle: windows_utils.PipeHandle, timeout: int | None = None) -> bool: ...
+        def close(self) -> None: ...
+        if sys.version_info >= (3, 11):
+            def recvfrom_into(
+                self, conn: socket.socket, buf: WriteableBuffer, flags: int = 0
+            ) -> futures.Future[tuple[int, socket._RetAddress]]: ...
+
+    SelectorEventLoop = _WindowsSelectorEventLoop
+
+    if sys.version_info >= (3, 14):
+        class _WindowsSelectorEventLoopPolicy(events._BaseDefaultEventLoopPolicy):
+            _loop_factory: ClassVar[type[SelectorEventLoop]]
+
+        class _WindowsProactorEventLoopPolicy(events._BaseDefaultEventLoopPolicy):
+            _loop_factory: ClassVar[type[ProactorEventLoop]]
+
+    else:
+        class WindowsSelectorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
+            _loop_factory: ClassVar[type[SelectorEventLoop]]
+            def get_child_watcher(self) -> NoReturn: ...
+            def set_child_watcher(self, watcher: Any) -> NoReturn: ...
+
+        class WindowsProactorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
+            _loop_factory: ClassVar[type[ProactorEventLoop]]
+            def get_child_watcher(self) -> NoReturn: ...
+            def set_child_watcher(self, watcher: Any) -> NoReturn: ...
+
+    if sys.version_info >= (3, 14):
+        _DefaultEventLoopPolicy = _WindowsProactorEventLoopPolicy
+    else:
+        DefaultEventLoopPolicy = WindowsProactorEventLoopPolicy
+    if sys.version_info >= (3, 13):
+        EventLoop = ProactorEventLoop