superacli 1.1.5 → 1.1.7

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

@@ -1,376 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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]