layermap 0.1.0

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

@@ -0,0 +1,374 @@
+import _typeshed
+import sys
+import types
+from _typeshed import SupportsKeysAndGetItem, Unused
+from builtins import property as _builtins_property
+from collections.abc import Callable, Iterable, Iterator, Mapping
+from typing import Any, Final, Generic, Literal, SupportsIndex, TypeAlias, TypeVar, overload
+from typing_extensions import Self, disjoint_base
+
+__all__ = ["EnumMeta", "Enum", "IntEnum", "Flag", "IntFlag", "auto", "unique"]
+
+if sys.version_info >= (3, 11):
+    __all__ += [
+        "CONFORM",
+        "CONTINUOUS",
+        "EJECT",
+        "EnumCheck",
+        "EnumType",
+        "FlagBoundary",
+        "KEEP",
+        "NAMED_FLAGS",
+        "ReprEnum",
+        "STRICT",
+        "StrEnum",
+        "UNIQUE",
+        "global_enum",
+        "global_enum_repr",
+        "global_flag_repr",
+        "global_str",
+        "member",
+        "nonmember",
+        "property",
+        "verify",
+        "pickle_by_enum_name",
+        "pickle_by_global_name",
+    ]
+
+if sys.version_info >= (3, 13):
+    __all__ += ["EnumDict"]
+if sys.version_info >= (3, 15):
+    __all__ += ["show_flag_values", "bin"]
+
+_EnumMemberT = TypeVar("_EnumMemberT")
+_EnumerationT = TypeVar("_EnumerationT", bound=type[Enum])
+
+# The following all work:
+# >>> from enum import Enum
+# >>> from string import ascii_lowercase
+# >>> Enum('Foo', names='RED YELLOW GREEN')
+# <enum 'Foo'>
+# >>> Enum('Foo', names=[('RED', 1), ('YELLOW, 2)])
+# <enum 'Foo'>
+# >>> Enum('Foo', names=((x for x in (ascii_lowercase[i], i)) for i in range(5)))
+# <enum 'Foo'>
+# >>> Enum('Foo', names={'RED': 1, 'YELLOW': 2})
+# <enum 'Foo'>
+_EnumNames: TypeAlias = str | Iterable[str] | Iterable[Iterable[str | Any]] | Mapping[str, Any]
+_Signature: TypeAlias = Any  # TODO: Unable to import Signature from inspect module
+
+if sys.version_info >= (3, 11):
+    class nonmember(Generic[_EnumMemberT]):
+        value: _EnumMemberT
+        def __init__(self, value: _EnumMemberT) -> None: ...
+
+    class member(Generic[_EnumMemberT]):
+        value: _EnumMemberT
+        def __init__(self, value: _EnumMemberT) -> None: ...
+
+class _EnumDict(dict[str, Any]):
+    if sys.version_info >= (3, 13):
+        def __init__(self, cls_name: str | None = None) -> None: ...
+    else:
+        def __init__(self) -> None: ...
+
+    def __setitem__(self, key: str, value: Any) -> None: ...
+    if sys.version_info >= (3, 11):
+        # See comment above `typing.MutableMapping.update`
+        # for why overloads are preferable to a Union here
+        #
+        # Unlike with MutableMapping.update(), the first argument is required,
+        # hence the type: ignore
+        @overload  # type: ignore[override]
+        def update(self, members: SupportsKeysAndGetItem[str, Any], **more_members: Any) -> None: ...
+        @overload
+        def update(self, members: Iterable[tuple[str, Any]], **more_members: Any) -> None: ...
+
+    if sys.version_info >= (3, 13):
+        @property
+        def member_names(self) -> list[str]: ...
+
+if sys.version_info >= (3, 13):
+    EnumDict = _EnumDict
+
+# Structurally: Iterable[T], Reversible[T], Container[T] where T is the enum itself
+class EnumMeta(type):
+    if sys.version_info >= (3, 11):
+        def __new__(
+            metacls: type[_typeshed.Self],
+            cls: str,
+            bases: tuple[type, ...],
+            classdict: _EnumDict,
+            *,
+            boundary: FlagBoundary | None = None,
+            _simple: bool = False,
+            **kwds: Any,
+        ) -> _typeshed.Self: ...
+    else:
+        def __new__(
+            metacls: type[_typeshed.Self], cls: str, bases: tuple[type, ...], classdict: _EnumDict, **kwds: Any
+        ) -> _typeshed.Self: ...
+
+    @classmethod
+    def __prepare__(metacls, cls: str, bases: tuple[type, ...], **kwds: Any) -> _EnumDict: ...  # type: ignore[override]
+    def __iter__(self: type[_EnumMemberT]) -> Iterator[_EnumMemberT]: ...
+    def __reversed__(self: type[_EnumMemberT]) -> Iterator[_EnumMemberT]: ...
+    if sys.version_info >= (3, 12):
+        def __contains__(self: type[Any], value: object) -> bool: ...
+    elif sys.version_info >= (3, 11):
+        def __contains__(self: type[Any], member: object) -> bool: ...
+    else:
+        def __contains__(self: type[Any], obj: object) -> bool: ...
+
+    def __getitem__(self: type[_EnumMemberT], name: str) -> _EnumMemberT: ...
+    @_builtins_property
+    def __members__(self: type[_EnumMemberT]) -> types.MappingProxyType[str, _EnumMemberT]: ...
+    def __len__(self) -> int: ...
+    def __bool__(self) -> Literal[True]: ...
+    def __dir__(self) -> list[str]: ...
+
+    # Overload 1: Value lookup on an already existing enum class (simple case)
+    @overload
+    def __call__(cls: type[_EnumMemberT], value: Any, names: None = None) -> _EnumMemberT: ...
+
+    # Overload 2: Functional API for constructing new enum classes.
+    if sys.version_info >= (3, 11):
+        @overload
+        def __call__(
+            cls,
+            value: str,
+            names: _EnumNames,
+            *,
+            module: str | None = None,
+            qualname: str | None = None,
+            type: type | None = None,
+            start: int = 1,
+            boundary: FlagBoundary | None = None,
+        ) -> type[Enum]: ...
+    else:
+        @overload
+        def __call__(
+            cls,
+            value: str,
+            names: _EnumNames,
+            *,
+            module: str | None = None,
+            qualname: str | None = None,
+            type: type | None = None,
+            start: int = 1,
+        ) -> type[Enum]: ...
+
+    # Overload 3 (py312+ only): Value lookup on an already existing enum class (complex case)
+    #
+    # >>> class Foo(enum.Enum):
+    # ...     X = 1, 2, 3
+    # >>> Foo(1, 2, 3)
+    # <Foo.X: (1, 2, 3)>
+    #
+    if sys.version_info >= (3, 12):
+        @overload
+        def __call__(cls: type[_EnumMemberT], value: Any, *values: Any) -> _EnumMemberT: ...
+    if sys.version_info >= (3, 14):
+        @property
+        def __signature__(cls) -> _Signature: ...
+
+    _member_names_: list[str]  # undocumented
+    _member_map_: dict[str, Enum]  # undocumented
+    _value2member_map_: dict[Any, Enum]  # undocumented
+
+if sys.version_info >= (3, 11):
+    # In 3.11 `EnumMeta` metaclass is renamed to `EnumType`, but old name also exists.
+    EnumType = EnumMeta
+
+    class property(types.DynamicClassAttribute):
+        def __set_name__(self, ownerclass: type[Enum], name: str) -> None: ...
+        name: str
+        clsname: str
+        member: Enum | None
+
+    _magic_enum_attr = property
+else:
+    _magic_enum_attr = types.DynamicClassAttribute
+
+class Enum(metaclass=EnumMeta):
+    @_magic_enum_attr
+    def name(self) -> str: ...
+    @_magic_enum_attr
+    def value(self) -> Any: ...
+    _name_: str
+    _value_: Any
+    _ignore_: str | list[str]
+    _order_: str
+    __order__: str
+    @classmethod
+    def _missing_(cls, value: object) -> Any: ...
+    @staticmethod
+    def _generate_next_value_(name: str, start: int, count: int, last_values: list[Any]) -> Any: ...
+    # It's not true that `__new__` will accept any argument type,
+    # so ideally we'd use `Any` to indicate that the argument type is inexpressible.
+    # However, using `Any` causes too many false-positives for those using mypy's `--disallow-any-expr`
+    # (see #7752, #2539, mypy/#5788),
+    # and in practice using `object` here has the same effect as using `Any`.
+    def __new__(cls, value: object) -> Self: ...
+    def __dir__(self) -> list[str]: ...
+    def __hash__(self) -> int: ...
+    def __format__(self, format_spec: str) -> str: ...
+    def __reduce_ex__(self, proto: Unused) -> tuple[Any, ...]: ...
+    if sys.version_info >= (3, 11):
+        def __copy__(self) -> Self: ...
+        def __deepcopy__(self, memo: Any) -> Self: ...
+    if sys.version_info >= (3, 12) and sys.version_info < (3, 14):
+        @classmethod
+        def __signature__(cls) -> str: ...
+    if sys.version_info >= (3, 13):
+        # Value may be any type, even in special enums. Enabling Enum parsing from
+        # multiple value types
+        def _add_value_alias_(self, value: Any) -> None: ...
+        def _add_alias_(self, name: str) -> None: ...
+
+if sys.version_info >= (3, 11):
+    class ReprEnum(Enum): ...
+
+if sys.version_info >= (3, 12):
+    class IntEnum(int, ReprEnum):
+        _value_: int
+        @_magic_enum_attr
+        def value(self) -> int: ...
+        def __new__(cls, value: int) -> Self: ...
+
+else:
+    if sys.version_info >= (3, 11):
+        _IntEnumBase = ReprEnum
+    else:
+        _IntEnumBase = Enum
+
+    @disjoint_base
+    class IntEnum(int, _IntEnumBase):
+        _value_: int
+        @_magic_enum_attr
+        def value(self) -> int: ...
+        def __new__(cls, value: int) -> Self: ...
+
+def unique(enumeration: _EnumerationT) -> _EnumerationT: ...
+
+_auto_null: Any
+
+class Flag(Enum):
+    _name_: str | None  # type: ignore[assignment]
+    _value_: int
+    _numeric_repr_: Callable[[int], str]
+    @_magic_enum_attr
+    def name(self) -> str | None: ...  # type: ignore[override]
+    @_magic_enum_attr
+    def value(self) -> int: ...
+    def __contains__(self, other: Self) -> bool: ...
+    def __bool__(self) -> bool: ...
+    def __or__(self, other: Self) -> Self: ...
+    def __and__(self, other: Self) -> Self: ...
+    def __xor__(self, other: Self) -> Self: ...
+    def __invert__(self) -> Self: ...
+    if sys.version_info >= (3, 11):
+        def __iter__(self) -> Iterator[Self]: ...
+        def __len__(self) -> int: ...
+        __ror__ = __or__
+        __rand__ = __and__
+        __rxor__ = __xor__
+
+if sys.version_info >= (3, 11):
+    class StrEnum(str, ReprEnum):
+        def __new__(cls, value: str) -> Self: ...
+        _value_: str
+        @_magic_enum_attr
+        def value(self) -> str: ...
+        @staticmethod
+        def _generate_next_value_(name: str, start: int, count: int, last_values: list[str]) -> str: ...
+
+    class EnumCheck(StrEnum):
+        CONTINUOUS = "no skipped integer values"
+        NAMED_FLAGS = "multi-flag aliases may not contain unnamed flags"
+        UNIQUE = "one name per value"
+
+    CONTINUOUS: Final = EnumCheck.CONTINUOUS
+    NAMED_FLAGS: Final = EnumCheck.NAMED_FLAGS
+    UNIQUE: Final = EnumCheck.UNIQUE
+
+    class verify:
+        def __init__(self, *checks: EnumCheck) -> None: ...
+        def __call__(self, enumeration: _EnumerationT) -> _EnumerationT: ...
+
+    class FlagBoundary(StrEnum):
+        STRICT = "strict"
+        CONFORM = "conform"
+        EJECT = "eject"
+        KEEP = "keep"
+
+    STRICT: Final = FlagBoundary.STRICT
+    CONFORM: Final = FlagBoundary.CONFORM
+    EJECT: Final = FlagBoundary.EJECT
+    KEEP: Final = FlagBoundary.KEEP
+
+    def global_str(self: Enum) -> str: ...
+    def global_enum(cls: _EnumerationT, update_str: bool = False) -> _EnumerationT: ...
+    def global_enum_repr(self: Enum) -> str: ...
+    def global_flag_repr(self: Flag) -> str: ...
+    def show_flag_values(value: int) -> list[int]: ...
+    def bin(num: SupportsIndex, max_bits: int | None = None) -> str: ...
+
+if sys.version_info >= (3, 12):
+    # The body of the class is the same, but the base classes are different.
+    class IntFlag(int, ReprEnum, Flag, boundary=KEEP):  # type: ignore[misc]  # complaints about incompatible bases
+        def __new__(cls, value: int) -> Self: ...
+        def __or__(self, other: int) -> Self: ...
+        def __and__(self, other: int) -> Self: ...
+        def __xor__(self, other: int) -> Self: ...
+        def __invert__(self) -> Self: ...
+        __ror__ = __or__
+        __rand__ = __and__
+        __rxor__ = __xor__
+
+elif sys.version_info >= (3, 11):
+    # The body of the class is the same, but the base classes are different.
+    @disjoint_base
+    class IntFlag(int, ReprEnum, Flag, boundary=KEEP):  # type: ignore[misc]  # complaints about incompatible bases
+        def __new__(cls, value: int) -> Self: ...
+        def __or__(self, other: int) -> Self: ...
+        def __and__(self, other: int) -> Self: ...
+        def __xor__(self, other: int) -> Self: ...
+        def __invert__(self) -> Self: ...
+        __ror__ = __or__
+        __rand__ = __and__
+        __rxor__ = __xor__
+
+else:
+    @disjoint_base
+    class IntFlag(int, Flag):  # type: ignore[misc]  # complaints about incompatible bases
+        def __new__(cls, value: int) -> Self: ...
+        def __or__(self, other: int) -> Self: ...
+        def __and__(self, other: int) -> Self: ...
+        def __xor__(self, other: int) -> Self: ...
+        def __invert__(self) -> Self: ...
+        __ror__ = __or__
+        __rand__ = __and__
+        __rxor__ = __xor__
+
+class auto:
+    _value_: Any
+    @_magic_enum_attr
+    def value(self) -> Any: ...
+    def __new__(cls) -> Self: ...
+
+    # These don't exist, but auto is basically immediately replaced with
+    # either an int or a str depending on the type of the enum. StrEnum's auto
+    # shouldn't have these, but they're needed for int versions of auto (mostly the __or__).
+    # Ideally type checkers would special case auto enough to handle this,
+    # but until then this is a slightly inaccurate helping hand.
+    def __or__(self, other: int | Self) -> Self: ...
+    def __and__(self, other: int | Self) -> Self: ...
+    def __xor__(self, other: int | Self) -> Self: ...
+    __ror__ = __or__
+    __rand__ = __and__
+    __rxor__ = __xor__
+
+if sys.version_info >= (3, 11):
+    def pickle_by_global_name(self: Enum, proto: int) -> str: ...
+    def pickle_by_enum_name(self: _EnumMemberT, proto: int) -> tuple[Callable[..., Any], tuple[type[_EnumMemberT], str]]: ...

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

@@ -0,0 +1,227 @@
+import sys
+from collections.abc import Mapping
+from typing import Final
+
+errorcode: Mapping[int, str]
+
+EPERM: Final[int]
+ENOENT: Final[int]
+ESRCH: Final[int]
+EINTR: Final[int]
+EIO: Final[int]
+ENXIO: Final[int]
+E2BIG: Final[int]
+ENOEXEC: Final[int]
+EBADF: Final[int]
+ECHILD: Final[int]
+EAGAIN: Final[int]
+ENOMEM: Final[int]
+EACCES: Final[int]
+EFAULT: Final[int]
+EBUSY: Final[int]
+EEXIST: Final[int]
+EXDEV: Final[int]
+ENODEV: Final[int]
+ENOTDIR: Final[int]
+EISDIR: Final[int]
+EINVAL: Final[int]
+ENFILE: Final[int]
+EMFILE: Final[int]
+ENOTTY: Final[int]
+ETXTBSY: Final[int]
+EFBIG: Final[int]
+ENOSPC: Final[int]
+ESPIPE: Final[int]
+EROFS: Final[int]
+EMLINK: Final[int]
+EPIPE: Final[int]
+EDOM: Final[int]
+ERANGE: Final[int]
+EDEADLK: Final[int]
+ENAMETOOLONG: Final[int]
+ENOLCK: Final[int]
+ENOSYS: Final[int]
+ENOTEMPTY: Final[int]
+ELOOP: Final[int]
+EWOULDBLOCK: Final[int]
+ENOMSG: Final[int]
+EIDRM: Final[int]
+ENOSTR: Final[int]
+ENODATA: Final[int]
+ETIME: Final[int]
+ENOSR: Final[int]
+EREMOTE: Final[int]
+ENOLINK: Final[int]
+EPROTO: Final[int]
+EBADMSG: Final[int]
+EOVERFLOW: Final[int]
+EILSEQ: Final[int]
+EUSERS: Final[int]
+ENOTSOCK: Final[int]
+EDESTADDRREQ: Final[int]
+EMSGSIZE: Final[int]
+EPROTOTYPE: Final[int]
+ENOPROTOOPT: Final[int]
+EPROTONOSUPPORT: Final[int]
+ESOCKTNOSUPPORT: Final[int]
+ENOTSUP: Final[int]
+EOPNOTSUPP: Final[int]
+EPFNOSUPPORT: Final[int]
+EAFNOSUPPORT: Final[int]
+EADDRINUSE: Final[int]
+EADDRNOTAVAIL: Final[int]
+ENETDOWN: Final[int]
+ENETUNREACH: Final[int]
+ENETRESET: Final[int]
+ECONNABORTED: Final[int]
+ECONNRESET: Final[int]
+ENOBUFS: Final[int]
+EISCONN: Final[int]
+ENOTCONN: Final[int]
+ESHUTDOWN: Final[int]
+ETOOMANYREFS: Final[int]
+ETIMEDOUT: Final[int]
+ECONNREFUSED: Final[int]
+EHOSTDOWN: Final[int]
+EHOSTUNREACH: Final[int]
+EALREADY: Final[int]
+EINPROGRESS: Final[int]
+ESTALE: Final[int]
+EDQUOT: Final[int]
+ECANCELED: Final[int]  # undocumented
+ENOTRECOVERABLE: Final[int]  # undocumented
+EOWNERDEAD: Final[int]  # undocumented
+
+if sys.platform == "sunos5" or sys.platform == "solaris":  # noqa: Y008
+    ELOCKUNMAPPED: Final[int]
+    ENOTACTIVE: Final[int]
+
+if sys.platform != "win32":
+    ENOTBLK: Final[int]
+    EMULTIHOP: Final[int]
+
+if sys.platform == "darwin":
+    # All of the below are undocumented
+    EAUTH: Final[int]
+    EBADARCH: Final[int]
+    EBADEXEC: Final[int]
+    EBADMACHO: Final[int]
+    EBADRPC: Final[int]
+    EDEVERR: Final[int]
+    EFTYPE: Final[int]
+    ENEEDAUTH: Final[int]
+    ENOATTR: Final[int]
+    ENOPOLICY: Final[int]
+    EPROCLIM: Final[int]
+    EPROCUNAVAIL: Final[int]
+    EPROGMISMATCH: Final[int]
+    EPROGUNAVAIL: Final[int]
+    EPWROFF: Final[int]
+    ERPCMISMATCH: Final[int]
+    ESHLIBVERS: Final[int]
+    if sys.version_info >= (3, 11):
+        EQFULL: Final[int]
+        ENOTCAPABLE: Final[int]  # available starting with 3.11.1
+
+if sys.platform != "darwin":
+    EDEADLOCK: Final[int]
+
+if sys.platform != "win32" and sys.platform != "darwin":
+    ECHRNG: Final[int]
+    EL2NSYNC: Final[int]
+    EL3HLT: Final[int]
+    EL3RST: Final[int]
+    ELNRNG: Final[int]
+    EUNATCH: Final[int]
+    ENOCSI: Final[int]
+    EL2HLT: Final[int]
+    EBADE: Final[int]
+    EBADR: Final[int]
+    EXFULL: Final[int]
+    ENOANO: Final[int]
+    EBADRQC: Final[int]
+    EBADSLT: Final[int]
+    EBFONT: Final[int]
+    ENONET: Final[int]
+    ENOPKG: Final[int]
+    EADV: Final[int]
+    ESRMNT: Final[int]
+    ECOMM: Final[int]
+    EDOTDOT: Final[int]
+    ENOTUNIQ: Final[int]
+    EBADFD: Final[int]
+    EREMCHG: Final[int]
+    ELIBACC: Final[int]
+    ELIBBAD: Final[int]
+    ELIBSCN: Final[int]
+    ELIBMAX: Final[int]
+    ELIBEXEC: Final[int]
+    ERESTART: Final[int]
+    ESTRPIPE: Final[int]
+    EUCLEAN: Final[int]
+    ENOTNAM: Final[int]
+    ENAVAIL: Final[int]
+    EISNAM: Final[int]
+    EREMOTEIO: Final[int]
+    # All of the below are undocumented
+    EKEYEXPIRED: Final[int]
+    EKEYREJECTED: Final[int]
+    EKEYREVOKED: Final[int]
+    EMEDIUMTYPE: Final[int]
+    ENOKEY: Final[int]
+    ENOMEDIUM: Final[int]
+    ERFKILL: Final[int]
+
+    if sys.version_info >= (3, 14):
+        EHWPOISON: Final[int]
+
+if sys.platform == "win32":
+    # All of these are undocumented
+    WSABASEERR: Final[int]
+    WSAEACCES: Final[int]
+    WSAEADDRINUSE: Final[int]
+    WSAEADDRNOTAVAIL: Final[int]
+    WSAEAFNOSUPPORT: Final[int]
+    WSAEALREADY: Final[int]
+    WSAEBADF: Final[int]
+    WSAECONNABORTED: Final[int]
+    WSAECONNREFUSED: Final[int]
+    WSAECONNRESET: Final[int]
+    WSAEDESTADDRREQ: Final[int]
+    WSAEDISCON: Final[int]
+    WSAEDQUOT: Final[int]
+    WSAEFAULT: Final[int]
+    WSAEHOSTDOWN: Final[int]
+    WSAEHOSTUNREACH: Final[int]
+    WSAEINPROGRESS: Final[int]
+    WSAEINTR: Final[int]
+    WSAEINVAL: Final[int]
+    WSAEISCONN: Final[int]
+    WSAELOOP: Final[int]
+    WSAEMFILE: Final[int]
+    WSAEMSGSIZE: Final[int]
+    WSAENAMETOOLONG: Final[int]
+    WSAENETDOWN: Final[int]
+    WSAENETRESET: Final[int]
+    WSAENETUNREACH: Final[int]
+    WSAENOBUFS: Final[int]
+    WSAENOPROTOOPT: Final[int]
+    WSAENOTCONN: Final[int]
+    WSAENOTEMPTY: Final[int]
+    WSAENOTSOCK: Final[int]
+    WSAEOPNOTSUPP: Final[int]
+    WSAEPFNOSUPPORT: Final[int]
+    WSAEPROCLIM: Final[int]
+    WSAEPROTONOSUPPORT: Final[int]
+    WSAEPROTOTYPE: Final[int]
+    WSAEREMOTE: Final[int]
+    WSAESHUTDOWN: Final[int]
+    WSAESOCKTNOSUPPORT: Final[int]
+    WSAESTALE: Final[int]
+    WSAETIMEDOUT: Final[int]
+    WSAETOOMANYREFS: Final[int]
+    WSAEUSERS: Final[int]
+    WSAEWOULDBLOCK: Final[int]
+    WSANOTINITIALISED: Final[int]
+    WSASYSNOTREADY: Final[int]
+    WSAVERNOTSUPPORTED: Final[int]

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

@@ -0,0 +1,61 @@
+import sys
+from _typeshed import FileDescriptorLike
+
+def cancel_dump_traceback_later() -> None: ...
+def disable() -> None: ...
+
+if sys.version_info >= (3, 15):
+    def dump_traceback(
+        file: FileDescriptorLike = sys.stderr, all_threads: bool = True, *, max_threads: int | None = None
+    ) -> None: ...
+
+else:
+    def dump_traceback(file: FileDescriptorLike = sys.stderr, all_threads: bool = True) -> None: ...
+
+if sys.version_info >= (3, 14):
+    def dump_c_stack(file: FileDescriptorLike = sys.stderr) -> None: ...
+
+if sys.version_info >= (3, 15):
+    def dump_traceback_later(
+        timeout: float,
+        repeat: bool = False,
+        file: FileDescriptorLike = sys.stderr,
+        exit: bool = False,
+        *,
+        max_threads: int | None = None,
+    ) -> None: ...
+
+else:
+    def dump_traceback_later(
+        timeout: float, repeat: bool = False, file: FileDescriptorLike = sys.stderr, exit: bool = False
+    ) -> None: ...
+
+if sys.version_info >= (3, 15):
+    def enable(
+        file: FileDescriptorLike = sys.stderr, all_threads: bool = True, c_stack: bool = True, *, max_threads: int | None = None
+    ) -> None: ...
+
+elif sys.version_info >= (3, 14):
+    def enable(file: FileDescriptorLike = sys.stderr, all_threads: bool = True, c_stack: bool = True) -> None: ...
+
+else:
+    def enable(file: FileDescriptorLike = sys.stderr, all_threads: bool = True) -> None: ...
+
+def is_enabled() -> bool: ...
+
+if sys.platform != "win32":
+    if sys.version_info >= (3, 15):
+        def register(
+            signum: int,
+            file: FileDescriptorLike = sys.stderr,
+            all_threads: bool = True,
+            chain: bool = False,
+            *,
+            max_threads: int | None = None,
+        ) -> None: ...
+    else:
+        def register(
+            signum: int, file: FileDescriptorLike = sys.stderr, all_threads: bool = True, chain: bool = False
+        ) -> None: ...
+
+    def unregister(signum: int, /) -> None: ...