basedpyright 1.1.389 → 1.1.392

package/dist/typeshed-fallback/stdlib/enum.pyi

@@ -1,348 +1,348 @@
-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, Generic, Literal, TypeVar, overload
-from typing_extensions import Self, TypeAlias
-
-__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]
-
-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]):
-    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: ...
-    elif sys.version_info >= (3, 9):
-        def __new__(
-            metacls: type[_typeshed.Self], cls: str, bases: tuple[type, ...], classdict: _EnumDict, **kwds: Any
-        ) -> _typeshed.Self: ...
-    else:
-        def __new__(metacls: type[_typeshed.Self], cls: str, bases: tuple[type, ...], classdict: _EnumDict) -> _typeshed.Self: ...
-
-    if sys.version_info >= (3, 9):
-        @classmethod
-        def __prepare__(metacls, cls: str, bases: tuple[type, ...], **kwds: Any) -> _EnumDict: ...  # type: ignore[override]
-    else:
-        @classmethod
-        def __prepare__(metacls, cls: str, bases: tuple[type, ...]) -> _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]:
-        """
-        Returns a mapping of member name->value.
-
-        This mapping lists all enum members, including aliases. Note that this
-        is a read-only view of the internal mapping.
-        """
-        ...
-    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: ...
-
-    _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):
-        @classmethod
-        def __signature__(cls) -> str: ...
-
-if sys.version_info >= (3, 11):
-    class ReprEnum(Enum): ...
-
-if sys.version_info >= (3, 11):
-    _IntEnumBase = ReprEnum
-else:
-    _IntEnumBase = Enum
-
-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
-    @_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 = EnumCheck.CONTINUOUS
-    NAMED_FLAGS = EnumCheck.NAMED_FLAGS
-    UNIQUE = 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 = FlagBoundary.STRICT
-    CONFORM = FlagBoundary.CONFORM
-    EJECT = FlagBoundary.EJECT
-    KEEP = 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: ...
-
-if sys.version_info >= (3, 11):
-    # 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: ...
-        __ror__ = __or__
-        __rand__ = __and__
-        __rxor__ = __xor__
-
-else:
-    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: ...
-        __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:
-        """Return self|value."""
-        ...
-    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]]: ...
+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, Generic, Literal, TypeVar, overload
+from typing_extensions import Self, TypeAlias
+
+__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]
+
+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]):
+    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: ...
+    elif sys.version_info >= (3, 9):
+        def __new__(
+            metacls: type[_typeshed.Self], cls: str, bases: tuple[type, ...], classdict: _EnumDict, **kwds: Any
+        ) -> _typeshed.Self: ...
+    else:
+        def __new__(metacls: type[_typeshed.Self], cls: str, bases: tuple[type, ...], classdict: _EnumDict) -> _typeshed.Self: ...
+
+    if sys.version_info >= (3, 9):
+        @classmethod
+        def __prepare__(metacls, cls: str, bases: tuple[type, ...], **kwds: Any) -> _EnumDict: ...  # type: ignore[override]
+    else:
+        @classmethod
+        def __prepare__(metacls, cls: str, bases: tuple[type, ...]) -> _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]:
+        """
+        Returns a mapping of member name->value.
+
+        This mapping lists all enum members, including aliases. Note that this
+        is a read-only view of the internal mapping.
+        """
+        ...
+    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: ...
+
+    _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):
+        @classmethod
+        def __signature__(cls) -> str: ...
+
+if sys.version_info >= (3, 11):
+    class ReprEnum(Enum): ...
+
+if sys.version_info >= (3, 11):
+    _IntEnumBase = ReprEnum
+else:
+    _IntEnumBase = Enum
+
+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
+    @_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 = EnumCheck.CONTINUOUS
+    NAMED_FLAGS = EnumCheck.NAMED_FLAGS
+    UNIQUE = 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 = FlagBoundary.STRICT
+    CONFORM = FlagBoundary.CONFORM
+    EJECT = FlagBoundary.EJECT
+    KEEP = 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: ...
+
+if sys.version_info >= (3, 11):
+    # 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: ...
+        __ror__ = __or__
+        __rand__ = __and__
+        __rxor__ = __xor__
+
+else:
+    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: ...
+        __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:
+        """Return self|value."""
+        ...
+    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]]: ...