superacli 1.1.4 → 1.1.6

package/ref-monty/crates/monty-typeshed/vendor/typeshed/stdlib/enum.pyi

@@ -0,0 +1,376 @@
+import sys
+import types
+from builtins import property as _builtins_property
+from collections.abc import Callable, Iterable, Iterator, Mapping
+from typing import Any, Final, Generic, Literal, SupportsIndex, TypeVar, overload
+
+import _typeshed
+from _typeshed import SupportsKeysAndGetItem, Unused
+from typing_extensions import Self, TypeAlias, 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']
+
+_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: ...
+    elif sys.version_info >= (3, 10):
+        def __contains__(self: type[Any], obj: object) -> bool: ...
+    else:
+        def __contains__(self: type[Any], member: 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/ref-monty/crates/monty-typeshed/vendor/typeshed/stdlib/math.pyi

@@ -0,0 +1,149 @@
+import sys
+from collections.abc import Iterable
+from typing import Any, Final, Literal, Protocol, SupportsFloat, SupportsIndex, TypeVar, overload, type_check_only
+
+from _typeshed import SupportsMul, SupportsRMul
+from typing_extensions import TypeAlias
+
+_T = TypeVar('_T')
+_T_co = TypeVar('_T_co', covariant=True)
+
+_SupportsFloatOrIndex: TypeAlias = SupportsFloat | SupportsIndex
+
+e: Final[float]
+pi: Final[float]
+inf: Final[float]
+nan: Final[float]
+tau: Final[float]
+
+def acos(x: _SupportsFloatOrIndex, /) -> float: ...
+def acosh(x: _SupportsFloatOrIndex, /) -> float: ...
+def asin(x: _SupportsFloatOrIndex, /) -> float: ...
+def asinh(x: _SupportsFloatOrIndex, /) -> float: ...
+def atan(x: _SupportsFloatOrIndex, /) -> float: ...
+def atan2(y: _SupportsFloatOrIndex, x: _SupportsFloatOrIndex, /) -> float: ...
+def atanh(x: _SupportsFloatOrIndex, /) -> float: ...
+
+if sys.version_info >= (3, 11):
+    def cbrt(x: _SupportsFloatOrIndex, /) -> float: ...
+
+@type_check_only
+class _SupportsCeil(Protocol[_T_co]):
+    def __ceil__(self) -> _T_co: ...
+
+@overload
+def ceil(x: _SupportsCeil[_T], /) -> _T: ...
+@overload
+def ceil(x: _SupportsFloatOrIndex, /) -> int: ...
+def comb(n: SupportsIndex, k: SupportsIndex, /) -> int: ...
+def copysign(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
+def cos(x: _SupportsFloatOrIndex, /) -> float: ...
+def cosh(x: _SupportsFloatOrIndex, /) -> float: ...
+def degrees(x: _SupportsFloatOrIndex, /) -> float: ...
+def dist(p: Iterable[_SupportsFloatOrIndex], q: Iterable[_SupportsFloatOrIndex], /) -> float: ...
+def erf(x: _SupportsFloatOrIndex, /) -> float: ...
+def erfc(x: _SupportsFloatOrIndex, /) -> float: ...
+def exp(x: _SupportsFloatOrIndex, /) -> float: ...
+
+if sys.version_info >= (3, 11):
+    def exp2(x: _SupportsFloatOrIndex, /) -> float: ...
+
+def expm1(x: _SupportsFloatOrIndex, /) -> float: ...
+def fabs(x: _SupportsFloatOrIndex, /) -> float: ...
+def factorial(x: SupportsIndex, /) -> int: ...
+@type_check_only
+class _SupportsFloor(Protocol[_T_co]):
+    def __floor__(self) -> _T_co: ...
+
+@overload
+def floor(x: _SupportsFloor[_T], /) -> _T: ...
+@overload
+def floor(x: _SupportsFloatOrIndex, /) -> int: ...
+def fmod(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
+def frexp(x: _SupportsFloatOrIndex, /) -> tuple[float, int]: ...
+def fsum(seq: Iterable[_SupportsFloatOrIndex], /) -> float: ...
+def gamma(x: _SupportsFloatOrIndex, /) -> float: ...
+def gcd(*integers: SupportsIndex) -> int: ...
+def hypot(*coordinates: _SupportsFloatOrIndex) -> float: ...
+def isclose(
+    a: _SupportsFloatOrIndex,
+    b: _SupportsFloatOrIndex,
+    *,
+    rel_tol: _SupportsFloatOrIndex = 1e-09,
+    abs_tol: _SupportsFloatOrIndex = 0.0,
+) -> bool: ...
+def isinf(x: _SupportsFloatOrIndex, /) -> bool: ...
+def isfinite(x: _SupportsFloatOrIndex, /) -> bool: ...
+def isnan(x: _SupportsFloatOrIndex, /) -> bool: ...
+def isqrt(n: SupportsIndex, /) -> int: ...
+def lcm(*integers: SupportsIndex) -> int: ...
+def ldexp(x: _SupportsFloatOrIndex, i: int, /) -> float: ...
+def lgamma(x: _SupportsFloatOrIndex, /) -> float: ...
+def log(x: _SupportsFloatOrIndex, base: _SupportsFloatOrIndex = ...) -> float: ...
+def log10(x: _SupportsFloatOrIndex, /) -> float: ...
+def log1p(x: _SupportsFloatOrIndex, /) -> float: ...
+def log2(x: _SupportsFloatOrIndex, /) -> float: ...
+def modf(x: _SupportsFloatOrIndex, /) -> tuple[float, float]: ...
+
+if sys.version_info >= (3, 12):
+    def nextafter(
+        x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /, *, steps: SupportsIndex | None = None
+    ) -> float: ...
+
+else:
+    def nextafter(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
+
+def perm(n: SupportsIndex, k: SupportsIndex | None = None, /) -> int: ...
+def pow(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
+
+_PositiveInteger: TypeAlias = Literal[
+    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25
+]
+_NegativeInteger: TypeAlias = Literal[
+    -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -20
+]
+_LiteralInteger = _PositiveInteger | _NegativeInteger | Literal[0]  # TODO: Use TypeAlias once mypy bugs are fixed
+
+_MultiplicableT1 = TypeVar('_MultiplicableT1', bound=SupportsMul[Any, Any])
+_MultiplicableT2 = TypeVar('_MultiplicableT2', bound=SupportsMul[Any, Any])
+
+@type_check_only
+class _SupportsProdWithNoDefaultGiven(SupportsMul[Any, Any], SupportsRMul[int, Any], Protocol): ...
+
+_SupportsProdNoDefaultT = TypeVar('_SupportsProdNoDefaultT', bound=_SupportsProdWithNoDefaultGiven)
+
+# This stub is based on the type stub for `builtins.sum`.
+# Like `builtins.sum`, it cannot be precisely represented in a type stub
+# without introducing many false positives.
+# For more details on its limitations and false positives, see #13572.
+# Instead, just like `builtins.sum`, we explicitly handle several useful cases.
+@overload
+def prod(iterable: Iterable[bool | _LiteralInteger], /, *, start: int = 1) -> int: ...  # type: ignore[overload-overlap]
+@overload
+def prod(iterable: Iterable[_SupportsProdNoDefaultT], /) -> _SupportsProdNoDefaultT | Literal[1]: ...
+@overload
+def prod(
+    iterable: Iterable[_MultiplicableT1], /, *, start: _MultiplicableT2
+) -> _MultiplicableT1 | _MultiplicableT2: ...
+def radians(x: _SupportsFloatOrIndex, /) -> float: ...
+def remainder(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
+def sin(x: _SupportsFloatOrIndex, /) -> float: ...
+def sinh(x: _SupportsFloatOrIndex, /) -> float: ...
+
+if sys.version_info >= (3, 12):
+    def sumprod(p: Iterable[float], q: Iterable[float], /) -> float: ...
+
+def sqrt(x: _SupportsFloatOrIndex, /) -> float: ...
+def tan(x: _SupportsFloatOrIndex, /) -> float: ...
+def tanh(x: _SupportsFloatOrIndex, /) -> float: ...
+
+# Is different from `_typeshed.SupportsTrunc`, which is not generic
+@type_check_only
+class _SupportsTrunc(Protocol[_T_co]):
+    def __trunc__(self) -> _T_co: ...
+
+def trunc(x: _SupportsTrunc[_T], /) -> _T: ...
+def ulp(x: _SupportsFloatOrIndex, /) -> float: ...
+
+if sys.version_info >= (3, 13):
+    def fma(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, z: _SupportsFloatOrIndex, /) -> float: ...

package/ref-monty/crates/monty-typeshed/vendor/typeshed/stdlib/os.pyi

@@ -0,0 +1,87 @@
+from abc import ABC, abstractmethod
+from typing import Callable, Protocol, TypeAlias, TypeVar, final, overload, runtime_checkable
+
+from _typeshed import AnyStr_co, structseq
+
+_T = TypeVar('_T')
+environ: dict[str, str]
+
+@overload
+def getenv(key: str) -> str | None: ...
+@overload
+def getenv(key: str, default: _T) -> str | _T: ...
+@final
+class stat_result(structseq[float], tuple[int, int, int, int, int, int, int, float, float, float]):
+    # The constructor of this class takes an iterable of variable length (though it must be at least 10).
+    #
+    # However, this class behaves like a tuple of 10 elements,
+    # no matter how long the iterable supplied to the constructor is.
+    # https://github.com/python/typeshed/pull/6560#discussion_r767162532
+    #
+    # The 10 elements always present are st_mode, st_ino, st_dev, st_nlink,
+    # st_uid, st_gid, st_size, st_atime, st_mtime, st_ctime.
+    #
+    # More items may be added at the end by some implementations.
+
+    @property
+    def st_mode(self) -> int:
+        """protection bits"""
+        ...
+
+    @property
+    def st_ino(self) -> int:
+        """inode"""
+        ...
+
+    @property
+    def st_dev(self) -> int:
+        """device"""
+        ...
+
+    @property
+    def st_nlink(self) -> int:
+        """number of hard links"""
+        ...
+
+    @property
+    def st_uid(self) -> int:
+        """user ID of owner"""
+        ...
+
+    @property
+    def st_gid(self) -> int:
+        """group ID of owner"""
+        ...
+
+    @property
+    def st_size(self) -> int:
+        """total size, in bytes"""
+        ...
+
+    @property
+    def st_atime(self) -> float:
+        """time of last access"""
+        ...
+
+    @property
+    def st_mtime(self) -> float:
+        """time of last modification"""
+        ...
+
+    @property
+    def st_ctime(self) -> float:
+        """time of last change"""
+        ...
+
+# (Samuel) PathLike is included here because it's used by pathlib
+
+# mypy and pyright object to this being both ABC and Protocol.
+# At runtime it inherits from ABC and is not a Protocol, but it will be
+# on the allowlist for use as a Protocol starting in 3.14.
+@runtime_checkable
+class PathLike(ABC, Protocol[AnyStr_co]):  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
+    __slots__ = ()
+    @abstractmethod
+    def __fspath__(self) -> AnyStr_co: ...
+
+_Opener: TypeAlias = Callable[[str, int], int]