mypy-dev 1.9.0.dev0__py3-none-any.whl

mypy/typeshed/stdlib/email/mime/image.pyi

@@ -0,0 +1,17 @@
+from collections.abc import Callable
+from email import _ParamsType
+from email.mime.nonmultipart import MIMENonMultipart
+from email.policy import Policy
+
+__all__ = ["MIMEImage"]
+
+class MIMEImage(MIMENonMultipart):
+    def __init__(
+        self,
+        _imagedata: str | bytes | bytearray,
+        _subtype: str | None = None,
+        _encoder: Callable[[MIMEImage], object] = ...,
+        *,
+        policy: Policy | None = None,
+        **_params: _ParamsType,
+    ) -> None: ...

mypy/typeshed/stdlib/email/mime/message.pyi

@@ -0,0 +1,8 @@
+from email.message import Message
+from email.mime.nonmultipart import MIMENonMultipart
+from email.policy import Policy
+
+__all__ = ["MIMEMessage"]
+
+class MIMEMessage(MIMENonMultipart):
+    def __init__(self, _msg: Message, _subtype: str = "rfc822", *, policy: Policy | None = None) -> None: ...

mypy/typeshed/stdlib/email/mime/multipart.pyi

@@ -0,0 +1,18 @@
+from collections.abc import Sequence
+from email import _ParamsType
+from email.message import Message
+from email.mime.base import MIMEBase
+from email.policy import Policy
+
+__all__ = ["MIMEMultipart"]
+
+class MIMEMultipart(MIMEBase):
+    def __init__(
+        self,
+        _subtype: str = "mixed",
+        boundary: str | None = None,
+        _subparts: Sequence[Message] | None = None,
+        *,
+        policy: Policy | None = None,
+        **_params: _ParamsType,
+    ) -> None: ...

mypy/typeshed/stdlib/email/mime/nonmultipart.pyi

@@ -0,0 +1,5 @@
+from email.mime.base import MIMEBase
+
+__all__ = ["MIMENonMultipart"]
+
+class MIMENonMultipart(MIMEBase): ...

mypy/typeshed/stdlib/email/mime/text.pyi

@@ -0,0 +1,9 @@
+from email.mime.nonmultipart import MIMENonMultipart
+from email.policy import Policy
+
+__all__ = ["MIMEText"]
+
+class MIMEText(MIMENonMultipart):
+    def __init__(
+        self, _text: str, _subtype: str = "plain", _charset: str | None = None, *, policy: Policy | None = None
+    ) -> None: ...

mypy/typeshed/stdlib/email/parser.pyi

@@ -0,0 +1,26 @@
+from _typeshed import SupportsRead
+from collections.abc import Callable
+from email.feedparser import BytesFeedParser as BytesFeedParser, FeedParser as FeedParser
+from email.message import Message
+from email.policy import Policy
+from typing import IO
+
+__all__ = ["Parser", "HeaderParser", "BytesParser", "BytesHeaderParser", "FeedParser", "BytesFeedParser"]
+
+class Parser:
+    def __init__(self, _class: Callable[[], Message] | None = None, *, policy: Policy = ...) -> None: ...
+    def parse(self, fp: SupportsRead[str], headersonly: bool = False) -> Message: ...
+    def parsestr(self, text: str, headersonly: bool = False) -> Message: ...
+
+class HeaderParser(Parser):
+    def parse(self, fp: SupportsRead[str], headersonly: bool = True) -> Message: ...
+    def parsestr(self, text: str, headersonly: bool = True) -> Message: ...
+
+class BytesParser:
+    def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ...
+    def parse(self, fp: IO[bytes], headersonly: bool = False) -> Message: ...
+    def parsebytes(self, text: bytes | bytearray, headersonly: bool = False) -> Message: ...
+
+class BytesHeaderParser(BytesParser):
+    def parse(self, fp: IO[bytes], headersonly: bool = True) -> Message: ...
+    def parsebytes(self, text: bytes | bytearray, headersonly: bool = True) -> Message: ...

mypy/typeshed/stdlib/email/policy.pyi

@@ -0,0 +1,38 @@
+from collections.abc import Callable
+from email._policybase import Compat32 as Compat32, Policy as Policy, compat32 as compat32
+from email.contentmanager import ContentManager
+from email.message import Message
+from typing import Any
+
+__all__ = ["Compat32", "compat32", "Policy", "EmailPolicy", "default", "strict", "SMTP", "HTTP"]
+
+class EmailPolicy(Policy):
+    utf8: bool
+    refold_source: str
+    header_factory: Callable[[str, Any], Any]
+    content_manager: ContentManager
+    def __init__(
+        self,
+        *,
+        max_line_length: int | None = ...,
+        linesep: str = ...,
+        cte_type: str = ...,
+        raise_on_defect: bool = ...,
+        mangle_from_: bool = ...,
+        message_factory: Callable[[Policy], Message] | None = ...,
+        utf8: bool = ...,
+        refold_source: str = ...,
+        header_factory: Callable[[str, str], str] = ...,
+        content_manager: ContentManager = ...,
+    ) -> None: ...
+    def header_source_parse(self, sourcelines: list[str]) -> tuple[str, str]: ...
+    def header_store_parse(self, name: str, value: Any) -> tuple[str, Any]: ...
+    def header_fetch_parse(self, name: str, value: str) -> Any: ...
+    def fold(self, name: str, value: str) -> Any: ...
+    def fold_binary(self, name: str, value: str) -> bytes: ...
+
+default: EmailPolicy
+SMTP: EmailPolicy
+SMTPUTF8: EmailPolicy
+HTTP: EmailPolicy
+strict: EmailPolicy

mypy/typeshed/stdlib/email/quoprimime.pyi

@@ -0,0 +1,28 @@
+from collections.abc import Iterable
+
+__all__ = [
+    "body_decode",
+    "body_encode",
+    "body_length",
+    "decode",
+    "decodestring",
+    "header_decode",
+    "header_encode",
+    "header_length",
+    "quote",
+    "unquote",
+]
+
+def header_check(octet: int) -> bool: ...
+def body_check(octet: int) -> bool: ...
+def header_length(bytearray: Iterable[int]) -> int: ...
+def body_length(bytearray: Iterable[int]) -> int: ...
+def unquote(s: str | bytes | bytearray) -> str: ...
+def quote(c: str | bytes | bytearray) -> str: ...
+def header_encode(header_bytes: bytes | bytearray, charset: str = "iso-8859-1") -> str: ...
+def body_encode(body: str, maxlinelen: int = 76, eol: str = "\n") -> str: ...
+def decode(encoded: str, eol: str = "\n") -> str: ...
+def header_decode(s: str) -> str: ...
+
+body_decode = decode
+decodestring = decode

mypy/typeshed/stdlib/email/utils.pyi

@@ -0,0 +1,66 @@
+import datetime
+import sys
+from _typeshed import Unused
+from email import _ParamType
+from email.charset import Charset
+from typing import overload
+from typing_extensions import TypeAlias
+
+__all__ = [
+    "collapse_rfc2231_value",
+    "decode_params",
+    "decode_rfc2231",
+    "encode_rfc2231",
+    "formataddr",
+    "formatdate",
+    "format_datetime",
+    "getaddresses",
+    "make_msgid",
+    "mktime_tz",
+    "parseaddr",
+    "parsedate",
+    "parsedate_tz",
+    "parsedate_to_datetime",
+    "unquote",
+]
+
+_PDTZ: TypeAlias = tuple[int, int, int, int, int, int, int, int, int, int | None]
+
+def quote(str: str) -> str: ...
+def unquote(str: str) -> str: ...
+def parseaddr(addr: str | None) -> tuple[str, str]: ...
+def formataddr(pair: tuple[str | None, str], charset: str | Charset = "utf-8") -> str: ...
+def getaddresses(fieldvalues: list[str]) -> list[tuple[str, str]]: ...
+@overload
+def parsedate(data: None) -> None: ...
+@overload
+def parsedate(data: str) -> tuple[int, int, int, int, int, int, int, int, int] | None: ...
+@overload
+def parsedate_tz(data: None) -> None: ...
+@overload
+def parsedate_tz(data: str) -> _PDTZ | None: ...
+
+if sys.version_info >= (3, 10):
+    @overload
+    def parsedate_to_datetime(data: None) -> None: ...
+    @overload
+    def parsedate_to_datetime(data: str) -> datetime.datetime: ...
+
+else:
+    def parsedate_to_datetime(data: str) -> datetime.datetime: ...
+
+def mktime_tz(data: _PDTZ) -> int: ...
+def formatdate(timeval: float | None = None, localtime: bool = False, usegmt: bool = False) -> str: ...
+def format_datetime(dt: datetime.datetime, usegmt: bool = False) -> str: ...
+
+if sys.version_info >= (3, 12):
+    def localtime(dt: datetime.datetime | None = None, isdst: Unused = None) -> datetime.datetime: ...
+
+else:
+    def localtime(dt: datetime.datetime | None = None, isdst: int = -1) -> datetime.datetime: ...
+
+def make_msgid(idstring: str | None = None, domain: str | None = None) -> str: ...
+def decode_rfc2231(s: str) -> tuple[str | None, str | None, str]: ...  # May return list[str]. See issue #10431 for details.
+def encode_rfc2231(s: str, charset: str | None = None, language: str | None = None) -> str: ...
+def collapse_rfc2231_value(value: _ParamType, errors: str = "replace", fallback_charset: str = "us-ascii") -> str: ...
+def decode_params(params: list[tuple[str, str]]) -> list[tuple[str, _ParamType]]: ...

mypy/typeshed/stdlib/encodings/__init__.pyi

@@ -0,0 +1,10 @@
+from _typeshed import Incomplete
+from codecs import CodecInfo
+
+class CodecRegistryError(LookupError, SystemError): ...
+
+def normalize_encoding(encoding: str | bytes) -> str: ...
+def search_function(encoding: str) -> CodecInfo | None: ...
+
+# Needed for submodules
+def __getattr__(name: str) -> Incomplete: ...

mypy/typeshed/stdlib/encodings/utf_8.pyi

@@ -0,0 +1,21 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    @staticmethod
+    def _buffer_decode(__data: ReadableBuffer, __errors: str | None = None, __final: bool = False) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    @staticmethod
+    def encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    @staticmethod
+    def decode(__data: ReadableBuffer, __errors: str | None = None, __final: bool = False) -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...
+def encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...

mypy/typeshed/stdlib/encodings/utf_8_sig.pyi

@@ -0,0 +1,22 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def __init__(self, errors: str = "strict") -> None: ...
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+    def getstate(self) -> int: ...
+    def setstate(self, state: int) -> None: ...  # type: ignore[override]
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    def __init__(self, errors: str = "strict") -> None: ...
+    def _buffer_decode(self, input: ReadableBuffer, errors: str | None, final: bool) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    def encode(self, input: str, errors: str | None = "strict") -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    def decode(self, input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...
+def encode(input: str, errors: str | None = "strict") -> tuple[bytes, int]: ...
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...

mypy/typeshed/stdlib/ensurepip/__init__.pyi

@@ -0,0 +1,12 @@
+__all__ = ["version", "bootstrap"]
+
+def version() -> str: ...
+def bootstrap(
+    *,
+    root: str | None = None,
+    upgrade: bool = False,
+    user: bool = False,
+    altinstall: bool = False,
+    default_pip: bool = False,
+    verbosity: int = 0,
+) -> None: ...

mypy/typeshed/stdlib/enum.pyi

@@ -0,0 +1,317 @@
+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",
+    ]
+
+if sys.version_info >= (3, 11):
+    __all__ += ["pickle_by_enum_name", "pickle_by_global_name"]
+
+_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: ...
+
+# 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]: ...
+    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: str
+        NAMED_FLAGS: str
+        UNIQUE: str
+    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: str
+        CONFORM: str
+        EJECT: str
+        KEEP: str
+    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__
+
+# subclassing IntFlag so it picks up all implemented base functions, best modeling behavior of enum.auto()
+class auto(IntFlag):
+    _value_: Any
+    @_magic_enum_attr
+    def value(self) -> Any: ...
+    def __new__(cls) -> Self: ...
+
+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]]: ...