diff --git a/mypy/typeops.py b/mypy/typeops.py
index 9e5e347533c6..f190168a18d7 100644
--- a/mypy/typeops.py
+++ b/mypy/typeops.py
@@ -650,8 +650,16 @@ def _remove_redundant_union_items(items: list[Type], keep_erased: bool) -> list[
 def _get_type_method_ret_type(t: Type, *, name: str) -> Type | None:
     t = get_proper_type(t)
 
+    # For Enum literals the ret_type can change based on the Enum
+    # we need to check the type of the enum rather than the literal
+    if isinstance(t, LiteralType) and t.is_enum_literal():
+        t = t.fallback
+
     if isinstance(t, Instance):
         sym = t.type.get(name)
+        # Fallback to the metaclass for the lookup when necessary
+        if not sym and (m := t.type.metaclass_type):
+            sym = m.type.get(name)
         if sym:
             sym_type = get_proper_type(sym.type)
             if isinstance(sym_type, CallableType):
diff --git a/mypy/types.py b/mypy/types.py
index cc9c65299ee8..3a6933922902 100644
--- a/mypy/types.py
+++ b/mypy/types.py
@@ -2818,10 +2818,28 @@ def __init__(
         self.fallback = fallback
         self._hash = -1  # Cached hash value
 
+    # NOTE: Enum types are always truthy by default, but this can be changed
+    #       in subclasses, so we need to get the truthyness from the Enum
+    #       type rather than base it on the value (which is a non-empty
+    #       string for enums, so always truthy)
+    # TODO: We should consider moving this branch to the `can_be_true`
+    #       `can_be_false` properties instead, so the truthyness only
+    #       needs to be determined once per set of Enum literals.
+    #       However, the same can be said for `TypeAliasType` in some
+    #       cases and we only set the default based on the type it is
+    #       aliasing. So if we decide to change this, we may want to
+    #       change that as well. perf_compare output was inconclusive
+    #       but slightly favored this version, probably because we have
+    #       almost no test cases where we would redundantly compute
+    #       `can_be_false`/`can_be_true`.
     def can_be_false_default(self) -> bool:
+        if self.fallback.type.is_enum:
+            return self.fallback.can_be_false
         return not self.value
 
     def can_be_true_default(self) -> bool:
+        if self.fallback.type.is_enum:
+            return self.fallback.can_be_true
         return bool(self.value)
 
     def accept(self, visitor: TypeVisitor[T]) -> T:
diff --git a/test-data/unit/check-custom-plugin.test b/test-data/unit/check-custom-plugin.test
index 666bf9680405..1e06f300570e 100644
--- a/test-data/unit/check-custom-plugin.test
+++ b/test-data/unit/check-custom-plugin.test
@@ -967,6 +967,7 @@ class Cls(enum.Enum):
     attr = 'test'
 
 reveal_type(Cls.attr)  # N: Revealed type is "builtins.int"
+[builtins fixtures/enum.pyi]
 [file mypy.ini]
 \[mypy]
 plugins=<ROOT>/test-data/unit/plugins/class_attr_hook.py
diff --git a/test-data/unit/check-enum.test b/test-data/unit/check-enum.test
index 533da6652f8f..422beb5c82f0 100644
--- a/test-data/unit/check-enum.test
+++ b/test-data/unit/check-enum.test
@@ -11,6 +11,8 @@ m = Medal.gold
 if int():
     m = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "Medal")
 
+[builtins fixtures/enum.pyi]
+
 -- Creation from Enum call
 -- -----------------------
 
@@ -79,6 +81,7 @@ from typing import Generic, TypeVar
 T = TypeVar("T")
 class Medal(Generic[T], metaclass=EnumMeta):  # E: Enum class cannot be generic
     q = None
+[builtins fixtures/enum.pyi]
 
 [case testEnumNameAndValue]
 from enum import Enum
@@ -175,6 +178,31 @@ def infer_truth(truth: Truth) -> None:
     reveal_type(truth.value) # N: Revealed type is "builtins.bool"
 [builtins fixtures/bool.pyi]
 
+[case testEnumTruthyness]
+# mypy: warn-unreachable
+import enum
+class E(enum.Enum):
+    x = 0
+if not E.x:
+    "noop"
+[builtins fixtures/tuple.pyi]
+[out]
+main:6: error: Statement is unreachable
+
+[case testEnumTruthynessCustomDunderBool]
+# mypy: warn-unreachable
+import enum
+from typing_extensions import Literal
+class E(enum.Enum):
+    x = 0
+    def __bool__(self) -> Literal[False]:
+        return False
+if E.x:
+    "noop"
+[builtins fixtures/enum.pyi]
+[out]
+main:9: error: Statement is unreachable
+
 [case testEnumUnique]
 import enum
 @enum.unique
@@ -183,6 +211,7 @@ class E(enum.Enum):
     y = 1  # NOTE: This duplicate value is not detected by mypy at the moment
 x = 1
 x = E.x
+[builtins fixtures/enum.pyi]
 [out]
 main:7: error: Incompatible types in assignment (expression has type "E", variable has type "int")
 
@@ -197,6 +226,7 @@ if int():
 s = ''
 if int():
     s = N.y # E: Incompatible types in assignment (expression has type "N", variable has type "str")
+[builtins fixtures/enum.pyi]
 
 [case testIntEnum_functionTakingIntEnum]
 from enum import IntEnum
@@ -207,6 +237,7 @@ def takes_some_int_enum(n: SomeIntEnum):
 takes_some_int_enum(SomeIntEnum.x)
 takes_some_int_enum(1)  # Error
 takes_some_int_enum(SomeIntEnum(1))  # How to deal with the above
+[builtins fixtures/enum.pyi]
 [out]
 main:7: error: Argument 1 to "takes_some_int_enum" has incompatible type "int"; expected "SomeIntEnum"
 
@@ -218,6 +249,7 @@ def takes_int(i: int):
     pass
 takes_int(SomeIntEnum.x)
 takes_int(2)
+[builtins fixtures/enum.pyi]
 
 [case testIntEnum_functionReturningIntEnum]
 from enum import IntEnum
@@ -230,6 +262,7 @@ an_int = returns_some_int_enum()
 
 an_enum = SomeIntEnum.x
 an_enum = returns_some_int_enum()
+[builtins fixtures/enum.pyi]
 [out]
 
 [case testStrEnumCreation]
@@ -244,6 +277,7 @@ reveal_type(MyStrEnum.x)  # N: Revealed type is "Literal[__main__.MyStrEnum.x]?"
 reveal_type(MyStrEnum.x.value)  # N: Revealed type is "Literal['x']?"
 reveal_type(MyStrEnum.y)  # N: Revealed type is "Literal[__main__.MyStrEnum.y]?"
 reveal_type(MyStrEnum.y.value)  # N: Revealed type is "Literal['y']?"
+[builtins fixtures/enum.pyi]
 [out]
 
 [case testEnumMethods]
@@ -278,6 +312,7 @@ takes_int(SomeExtIntEnum.x)
 def takes_some_ext_int_enum(s: SomeExtIntEnum):
     pass
 takes_some_ext_int_enum(SomeExtIntEnum.x)
+[builtins fixtures/enum.pyi]
 
 [case testNamedTupleEnum]
 from typing import NamedTuple
@@ -299,6 +334,7 @@ class E(IntEnum):
     a = 1
 x: int
 reveal_type(E(x))
+[builtins fixtures/tuple.pyi]
 [out]
 main:5: note: Revealed type is "__main__.E"
 
@@ -308,6 +344,7 @@ class E(IntEnum):
     a = 1
 s: str
 reveal_type(E[s])
+[builtins fixtures/enum.pyi]
 [out]
 main:5: note: Revealed type is "__main__.E"
 
@@ -317,6 +354,7 @@ class E(IntEnum):
     a = 1
 E[1]  # E: Enum index should be a string (actual index type "int")
 x = E[1]  # E: Enum index should be a string (actual index type "int")
+[builtins fixtures/enum.pyi]
 
 [case testEnumIndexIsNotAnAlias]
 from enum import Enum
@@ -334,6 +372,7 @@ def get_member(name: str) -> E:
     return val
 
 reveal_type(get_member('a'))  # N: Revealed type is "__main__.E"
+[builtins fixtures/enum.pyi]
 
 [case testGenericEnum]
 from enum import Enum
@@ -346,6 +385,7 @@ class F(Generic[T], Enum):  # E: Enum class cannot be generic
     y: T
 
 reveal_type(F[int].x)  # N: Revealed type is "__main__.F[builtins.int]"
+[builtins fixtures/enum.pyi]
 
 [case testEnumFlag]
 from enum import Flag
@@ -357,6 +397,7 @@ if int():
     x = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "C")
 if int():
     x = x | C.b
+[builtins fixtures/enum.pyi]
 
 [case testEnumIntFlag]
 from enum import IntFlag
@@ -368,6 +409,7 @@ if int():
     x = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "C")
 if int():
     x = x | C.b
+[builtins fixtures/enum.pyi]
 
 [case testAnonymousEnum]
 from enum import Enum
@@ -378,6 +420,7 @@ class A:
         self.x = E.a
 a = A()
 reveal_type(a.x)
+[builtins fixtures/enum.pyi]
 [out]
 main:8: note: Revealed type is "__main__.E@4"
 
@@ -393,6 +436,7 @@ x = A.E.a
 y = B.E.a
 if int():
     x = y # E: Incompatible types in assignment (expression has type "__main__.B.E", variable has type "__main__.A.E")
+[builtins fixtures/enum.pyi]
 
 [case testFunctionalEnumString]
 from enum import Enum, IntEnum
@@ -402,6 +446,7 @@ reveal_type(E.foo)
 reveal_type(E.bar.value)
 reveal_type(I.bar)
 reveal_type(I.baz.value)
+[builtins fixtures/enum.pyi]
 [out]
 main:4: note: Revealed type is "Literal[__main__.E.foo]?"
 main:5: note: Revealed type is "Any"
@@ -414,6 +459,7 @@ E = Enum('E', ('foo', 'bar'))
 F = IntEnum('F', ['bar', 'baz'])
 reveal_type(E.foo)
 reveal_type(F.baz)
+[builtins fixtures/enum.pyi]
 [out]
 main:4: note: Revealed type is "Literal[__main__.E.foo]?"
 main:5: note: Revealed type is "Literal[__main__.F.baz]?"
@@ -426,6 +472,7 @@ reveal_type(E.foo)
 reveal_type(F.baz)
 reveal_type(E.foo.value)
 reveal_type(F.bar.name)
+[builtins fixtures/enum.pyi]
 [out]
 main:4: note: Revealed type is "Literal[__main__.E.foo]?"
 main:5: note: Revealed type is "Literal[__main__.F.baz]?"
@@ -440,6 +487,7 @@ reveal_type(E.foo)
 reveal_type(F.baz)
 reveal_type(E.foo.value)
 reveal_type(F.bar.name)
+[builtins fixtures/enum.pyi]
 [out]
 main:4: note: Revealed type is "Literal[__main__.E.foo]?"
 main:5: note: Revealed type is "Literal[__main__.F.baz]?"
@@ -455,6 +503,7 @@ fake_enum1 = Enum('fake_enum1', ['a', 'b'])
 fake_enum2 = Enum('fake_enum2', names=['a', 'b'])
 fake_enum3 = Enum(value='fake_enum3', names=['a', 'b'])
 fake_enum4 = Enum(value='fake_enum4', names=['a', 'b'] , module=__name__)
+[builtins fixtures/enum.pyi]
 
 [case testFunctionalEnumErrors]
 from enum import Enum, IntEnum
@@ -484,6 +533,7 @@ X = Enum('Something', 'a b')  # E: String argument 1 "Something" to enum.Enum(..
 reveal_type(X.a)  # N: Revealed type is "Literal[__main__.Something@23.a]?"
 X.asdf  # E: "Type[Something@23]" has no attribute "asdf"
 
+[builtins fixtures/tuple.pyi]
 [typing fixtures/typing-medium.pyi]
 
 [case testFunctionalEnumFlag]
@@ -498,6 +548,7 @@ reveal_type(B.a.name)   # N: Revealed type is "Literal['a']?"
 # TODO: The revealed type should be 'int' here
 reveal_type(A.x.value)  # N: Revealed type is "Any"
 reveal_type(B.a.value)  # N: Revealed type is "Any"
+[builtins fixtures/enum.pyi]
 
 [case testAnonymousFunctionalEnum]
 from enum import Enum
@@ -507,6 +558,7 @@ class A:
         self.x = E.a
 a = A()
 reveal_type(a.x)
+[builtins fixtures/enum.pyi]
 [out]
 main:7: note: Revealed type is "__main__.A.E@4"
 
@@ -520,6 +572,7 @@ x = A.E.a
 y = B.E.a
 if int():
     x = y # E: Incompatible types in assignment (expression has type "__main__.B.E", variable has type "__main__.A.E")
+[builtins fixtures/enum.pyi]
 
 [case testFunctionalEnumProtocols]
 from enum import IntEnum
@@ -537,6 +590,7 @@ a: E = E.x  # type: ignore[used-before-def]
 class E(Enum):
     x = 1
     y = 2
+[builtins fixtures/enum.pyi]
 [out]
 
 [case testEnumWorkWithForward2]
@@ -547,6 +601,7 @@ F = Enum('F', {'x': 1, 'y': 2})
 def fn(x: F) -> None:
     pass
 fn(b)
+[builtins fixtures/enum.pyi]
 [out]
 
 [case testFunctionalEnum]
@@ -564,6 +619,7 @@ Gu.a
 Gb.a
 Hu.a
 Hb.a
+[builtins fixtures/enum.pyi]
 [out]
 
 [case testEnumIncremental]
@@ -576,6 +632,7 @@ class E(Enum):
     a = 1
     b = 2
 F = Enum('F', 'a b')
+[builtins fixtures/enum.pyi]
 [rechecked]
 [stale]
 [out1]
@@ -734,6 +791,7 @@ class SomeEnum(Enum):
 from enum import Enum
 class SomeEnum(Enum):
     a = "foo"
+[builtins fixtures/enum.pyi]
 [out]
 main:2: note: Revealed type is "Literal[1]?"
 [out2]
@@ -949,7 +1007,7 @@ x: Optional[Foo]
 if x:
     reveal_type(x)  # N: Revealed type is "__main__.Foo"
 else:
-    reveal_type(x)  # N: Revealed type is "Union[__main__.Foo, None]"
+    reveal_type(x)  # N: Revealed type is "None"
 
 if x is not None:
     reveal_type(x)  # N: Revealed type is "__main__.Foo"
@@ -961,7 +1019,7 @@ if x is Foo.A:
 else:
     reveal_type(x)  # N: Revealed type is "Union[Literal[__main__.Foo.B], Literal[__main__.Foo.C], None]"
 reveal_type(x) # N: Revealed type is "Union[__main__.Foo, None]"
-[builtins fixtures/bool.pyi]
+[builtins fixtures/enum.pyi]
 
 [case testEnumReachabilityWithMultipleEnums]
 from enum import Enum
@@ -1104,6 +1162,7 @@ class A:
         self.b = Enum("b", [("foo", "bar")])  # E: Enum type as attribute is not supported
 
 reveal_type(A().b)  # N: Revealed type is "Any"
+[builtins fixtures/enum.pyi]
 
 [case testEnumReachabilityWithChaining]
 from enum import Enum
@@ -1307,6 +1366,7 @@ class Foo(Enum):
 a = Foo.A
 reveal_type(a.value)    # N: Revealed type is "Union[Literal[1]?, Literal[2]?]"
 reveal_type(a._value_)  # N: Revealed type is "Union[Literal[1]?, Literal[2]?]"
+[builtins fixtures/enum.pyi]
 
 [case testNewSetsUnexpectedValueType]
 from enum import Enum
@@ -1325,7 +1385,7 @@ class Foo(bytes, Enum):
 a = Foo.A
 reveal_type(a.value)    # N: Revealed type is "Any"
 reveal_type(a._value_)  # N: Revealed type is "Any"
-[builtins fixtures/primitives.pyi]
+[builtins fixtures/tuple.pyi]
 [typing fixtures/typing-medium.pyi]
 
 [case testValueTypeWithNewInParentClass]
@@ -1398,6 +1458,7 @@ class E(IntEnum):
     A = N(0)
 
 reveal_type(E.A.value) # N: Revealed type is "__main__.N"
+[builtins fixtures/enum.pyi]
 
 
 [case testEnumFinalValues]
@@ -1410,6 +1471,7 @@ class Medal(Enum):
 Medal.gold = 0  # E: Cannot assign to final attribute "gold"
 # Same value:
 Medal.silver = 2  # E: Cannot assign to final attribute "silver"
+[builtins fixtures/enum.pyi]
 
 
 [case testEnumFinalValuesCannotRedefineValueProp]
@@ -1417,6 +1479,7 @@ from enum import Enum
 class Types(Enum):
     key = 0
     value = 1
+[builtins fixtures/enum.pyi]
 
 
 [case testEnumReusedKeys]
@@ -2035,7 +2098,7 @@ class C(Enum):
     _ignore_ = 'X'
 
 C._ignore_ # E: "Type[C]" has no attribute "_ignore_"
-[typing fixtures/typing-medium.pyi]
+[builtins fixtures/enum.pyi]
 
 [case testCanOverrideDunderAttributes]
 import typing
@@ -2114,6 +2177,7 @@ class AllPartialList(Enum):
 
     def check(self) -> None:
         reveal_type(self.value)  # N: Revealed type is "builtins.list[Any]"
+[builtins fixtures/tuple.pyi]
 
 [case testEnumPrivateAttributeNotMember]
 from enum import Enum
@@ -2125,6 +2189,7 @@ class MyEnum(Enum):
 
 # TODO: change the next line to use MyEnum._MyEnum__my_dict when mypy implements name mangling
 x: MyEnum = MyEnum.__my_dict  # E: Incompatible types in assignment (expression has type "Dict[int, str]", variable has type "MyEnum")
+[builtins fixtures/enum.pyi]
 
 [case testEnumWithPrivateAttributeReachability]
 # flags: --warn-unreachable
@@ -2202,6 +2267,7 @@ class Medal(Enum):
                      # N: See https://typing.readthedocs.io/en/latest/spec/enums.html#defining-members \
                      # E: Incompatible types in assignment (expression has type "int", variable has type "str")
     bronze = 3
+[builtins fixtures/enum.pyi]
 
 [case testEnumMemberWithPlaceholder]
 from enum import Enum
@@ -2211,6 +2277,7 @@ class Pet(Enum):
     DOG: str = ...  # E: Enum members must be left unannotated \
                     # N: See https://typing.readthedocs.io/en/latest/spec/enums.html#defining-members \
                     # E: Incompatible types in assignment (expression has type "ellipsis", variable has type "str")
+[builtins fixtures/enum.pyi]
 
 [case testEnumValueWithPlaceholderNodeType]
 # https://github.com/python/mypy/issues/11971
diff --git a/test-data/unit/check-incremental.test b/test-data/unit/check-incremental.test
index 173265e48e6f..888b4c26a7c7 100644
--- a/test-data/unit/check-incremental.test
+++ b/test-data/unit/check-incremental.test
@@ -6586,6 +6586,7 @@ class TheClass:
             for x in names
         })
         self.enum_type = pyenum
+[builtins fixtures/tuple.pyi]
 [out]
 [out2]
 tmp/a.py:3: note: Revealed type is "def (value: builtins.object) -> lib.TheClass.pyenum@6"
diff --git a/test-data/unit/check-newsemanal.test b/test-data/unit/check-newsemanal.test
index fe02ac3ccd5e..784b9db9f66e 100644
--- a/test-data/unit/check-newsemanal.test
+++ b/test-data/unit/check-newsemanal.test
@@ -2069,6 +2069,7 @@ from enum import Enum
 
 A = Enum('A', ['x', 'y'])
 A = Enum('A', ['z', 't'])  # E: Name "A" already defined on line 3
+[builtins fixtures/tuple.pyi]
 
 [case testNewAnalyzerNewTypeRedefinition]
 from typing import NewType
diff --git a/test-data/unit/check-python310.test b/test-data/unit/check-python310.test
index c7bd08900f5f..8f121e578130 100644
--- a/test-data/unit/check-python310.test
+++ b/test-data/unit/check-python310.test
@@ -1543,6 +1543,7 @@ def g(m: Medal) -> int:
         case Medal.bronze:
             reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.bronze]"
             return 2
+[builtins fixtures/enum.pyi]
 
 
 [case testMatchLiteralPatternEnumWithTypedAttribute]
@@ -1597,6 +1598,7 @@ match m:
         reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.bronze]"
     case _ as unreachable:
         assert_never(unreachable)
+[builtins fixtures/enum.pyi]
 
 [case testMatchLiteralPatternEnumCustomEquals-skip]
 from enum import Enum
@@ -1614,6 +1616,7 @@ match m:
         reveal_type(m)  # N: Revealed type is "Literal[__main__.Medal.gold]"
     case _:
         reveal_type(m)  # N: Revealed type is "__main__.Medal"
+[builtins fixtures/enum.pyi]
 
 [case testMatchNarrowUsingPatternGuardSpecialCase]
 def f(x: int | str) -> int:
@@ -1691,6 +1694,7 @@ def union(x: str | bool) -> None:
         case True:
             return
     reveal_type(x)  # N: Revealed type is "Union[builtins.str, Literal[False]]"
+[builtins fixtures/tuple.pyi]
 
 [case testMatchAssertFalseToSilenceFalsePositives]
 class C:
diff --git a/test-data/unit/deps-classes.test b/test-data/unit/deps-classes.test
index ebe2e9caed02..a8fc5d629491 100644
--- a/test-data/unit/deps-classes.test
+++ b/test-data/unit/deps-classes.test
@@ -178,6 +178,7 @@ def g() -> None:
     A.X
 [file m.py]
 class B: pass
+[builtins fixtures/enum.pyi]
 [out]
 <m.A.X> -> m.g
 <m.A> -> <m.f>, m.A, m.f, m.g
diff --git a/test-data/unit/deps-types.test b/test-data/unit/deps-types.test
index def117fe04df..6992a5bdec00 100644
--- a/test-data/unit/deps-types.test
+++ b/test-data/unit/deps-types.test
@@ -905,6 +905,7 @@ def g() -> None:
     A.X
 [file mod.py]
 class B: pass
+[builtins fixtures/tuple.pyi]
 [out]
 <m.A.X> -> m.g
 <m.A> -> <m.f>, m.f, m.g
diff --git a/test-data/unit/diff.test b/test-data/unit/diff.test
index 10fb0a80cf38..4acf451e2c34 100644
--- a/test-data/unit/diff.test
+++ b/test-data/unit/diff.test
@@ -566,6 +566,7 @@ A = Enum('A', 'x')
 B = Enum('B', 'y')
 C = IntEnum('C', 'x')
 D = IntEnum('D', 'x y')
+[builtins fixtures/enum.pyi]
 [out]
 __main__.B.x
 __main__.B.y
@@ -605,6 +606,7 @@ class D(Enum):
     Y = 'b'
 class F(Enum):
     X = 0
+[builtins fixtures/enum.pyi]
 [out]
 __main__.B.Y
 __main__.B.Z
diff --git a/test-data/unit/fine-grained.test b/test-data/unit/fine-grained.test
index a611320909e5..f30f1e232364 100644
--- a/test-data/unit/fine-grained.test
+++ b/test-data/unit/fine-grained.test
@@ -5355,6 +5355,7 @@ c: C
 c = C.X
 if int():
     c = 1
+[builtins fixtures/enum.pyi]
 [out]
 ==
 ==
@@ -5386,6 +5387,7 @@ if int():
     n = C.X
     if int():
         n = c
+[builtins fixtures/enum.pyi]
 [out]
 ==
 ==
@@ -5410,6 +5412,7 @@ from enum import Enum
 
 class C(Enum):
     X = 0
+[builtins fixtures/tuple.pyi]
 [typing fixtures/typing-medium.pyi]
 [out]
 ==
@@ -5432,6 +5435,7 @@ from enum import Enum
 class C(Enum):
     X = 0
     Y = 1
+[builtins fixtures/enum.pyi]
 [out]
 ==
 a.py:4: error: Argument 1 to "f" has incompatible type "C"; expected "int"
@@ -5456,6 +5460,7 @@ c: C
 c = C.X
 if int():
    c = 1
+[builtins fixtures/tuple.pyi]
 [out]
 ==
 ==
@@ -5485,6 +5490,7 @@ if int():
     n: int
     n = C.X
 n = c
+[builtins fixtures/enum.pyi]
 [out]
 ==
 ==
@@ -5506,6 +5512,7 @@ C = Enum('C', 'X Y')
 from enum import Enum
 
 C = Enum('C', 'X')
+[builtins fixtures/tuple.pyi]
 [typing fixtures/typing-medium.pyi]
 [out]
 ==
@@ -5526,6 +5533,7 @@ class C:
 [file b.py.2]
 from enum import Enum
 C = Enum('C', [('X', 0), ('Y', 1)])
+[builtins fixtures/tuple.pyi]
 [out]
 ==
 a.py:4: error: Argument 1 to "f" has incompatible type "C"; expected "int"
diff --git a/test-data/unit/fixtures/enum.pyi b/test-data/unit/fixtures/enum.pyi
new file mode 100644
index 000000000000..debffacf8f32
--- /dev/null
+++ b/test-data/unit/fixtures/enum.pyi
@@ -0,0 +1,16 @@
+# Minimal set of builtins required to work with Enums
+from typing import TypeVar, Generic
+
+T = TypeVar('T')
+
+class object:
+    def __init__(self): pass
+
+class type: pass
+class tuple(Generic[T]):
+    def __getitem__(self, x: int) -> T: pass
+
+class int: pass
+class str: pass
+class dict: pass
+class ellipsis: pass
diff --git a/test-data/unit/fixtures/staticmethod.pyi b/test-data/unit/fixtures/staticmethod.pyi
index 8a87121b2a71..a0ca831c7527 100644
--- a/test-data/unit/fixtures/staticmethod.pyi
+++ b/test-data/unit/fixtures/staticmethod.pyi
@@ -19,3 +19,4 @@ class str: pass
 class bytes: pass
 class ellipsis: pass
 class dict: pass
+class tuple: pass
diff --git a/test-data/unit/lib-stub/enum.pyi b/test-data/unit/lib-stub/enum.pyi
index 0e0b8e025d9f..ccb3818b9d25 100644
--- a/test-data/unit/lib-stub/enum.pyi
+++ b/test-data/unit/lib-stub/enum.pyi
@@ -1,4 +1,5 @@
 from typing import Any, TypeVar, Union, Type, Sized, Iterator
+from typing_extensions import Literal
 
 _T = TypeVar('_T')
 
@@ -7,6 +8,7 @@ class EnumMeta(type, Sized):
     def __iter__(self: Type[_T]) -> Iterator[_T]: pass
     def __reversed__(self: Type[_T]) -> Iterator[_T]: pass
     def __getitem__(self: Type[_T], name: str) -> _T: pass
+    def __bool__(self) -> Literal[True]: pass
 
 class Enum(metaclass=EnumMeta):
     def __new__(cls: Type[_T], value: object) -> _T: pass
diff --git a/test-data/unit/merge.test b/test-data/unit/merge.test
index 19b1839f86c0..a6a64c75b2a3 100644
--- a/test-data/unit/merge.test
+++ b/test-data/unit/merge.test
@@ -1490,6 +1490,7 @@ from enum import Enum
 class A(Enum):
     X = 0
     Y = 1
+[builtins fixtures/enum.pyi]
 [out]
 TypeInfo<0>(
   Name(target.A)