-   case: test_every_model_has_objects_queryset_available
    main: |
        from typing_extensions import reveal_type
        from myapp.models import User
        reveal_type(User.objects)  # N: Revealed type is "django.db.models.manager.Manager[myapp.models.User]"
        reveal_type(User.objects.get())  # N: Revealed type is "myapp.models.User"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from django.db import models
                class User(models.Model):
                    pass

-   case: every_model_has_its_own_objects_queryset
    main: |
        from typing_extensions import reveal_type
        from myapp.models import Parent, Child
        reveal_type(Parent.objects)  # N: Revealed type is "django.db.models.manager.Manager[myapp.models.Parent]"
        reveal_type(Child.objects)  # N: Revealed type is "django.db.models.manager.Manager[myapp.models.Child]"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from django.db import models
                class Parent(models.Model):
                    pass
                class Child(Parent):
                    pass

-   case: test_model_objects_attribute_present_in_case_of_model_cls_passed_as_generic_parameter
    main: |
        from typing_extensions import reveal_type
        from myapp.models import Base, MyModel
        base_instance = Base(MyModel)
        reveal_type(base_instance.model_cls._default_manager)  # N: Revealed type is "django.db.models.manager.Manager[myapp.models.MyModel]"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from typing import Generic, TypeVar
                from typing_extensions import reveal_type
                from django.db import models

                _T = TypeVar('_T', bound=models.Model)
                class Base(Generic[_T]):
                    def __init__(self, model_cls: type[_T]) -> None:
                        self.model_cls = model_cls
                        reveal_type(self.model_cls._default_manager)  # N: Revealed type is "django.db.models.manager.Manager[_T`1]"
                class MyModel(models.Model):
                    pass
                class Child(Base[MyModel]):
                    def method(self) -> None:
                        reveal_type(self.model_cls._default_manager)  # N: Revealed type is "django.db.models.manager.Manager[myapp.models.MyModel]"

-   case: test_base_manager_called_on_model_cls_as_generic_parameter
    main: |
        from typing_extensions import reveal_type
        from myapp.models import Base, MyModel
        base_instance = Base(MyModel)
        reveal_type(base_instance.model_cls._base_manager)  # N: Revealed type is "django.db.models.manager.Manager[myapp.models.MyModel]"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from typing import Generic, TypeVar
                from typing_extensions import reveal_type
                from django.db import models

                _T = TypeVar('_T', bound=models.Model)
                class Base(Generic[_T]):
                    def __init__(self, model_cls: type[_T]) -> None:
                        self.model_cls = model_cls
                        reveal_type(self.model_cls._base_manager)  # N: Revealed type is "django.db.models.manager.Manager[_T`1]"
                class MyModel(models.Model):
                    pass
                class Child(Base[MyModel]):
                    def method(self) -> None:
                        reveal_type(self.model_cls._base_manager)  # N: Revealed type is "django.db.models.manager.Manager[myapp.models.MyModel]"

-   case: if_custom_manager_defined_it_is_set_to_default_manager
    main: |
        from typing_extensions import reveal_type
        from myapp.models import MyModel
        reveal_type(MyModel._default_manager)  # N: Revealed type is "myapp.models.CustomManager[myapp.models.MyModel]"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from typing import TypeVar
                from django.db import models
                _T = TypeVar('_T', bound=models.Model)
                class CustomManager(models.Manager[_T]):
                    pass
                class MyModel(models.Model):
                    manager = CustomManager['MyModel']()

-   case: if_default_manager_name_is_passed_set_default_manager_to_it
    main: |
        from typing_extensions import reveal_type
        from myapp.models import MyModel
        reveal_type(MyModel._default_manager)  # N: Revealed type is "myapp.models.Manager2[myapp.models.MyModel]"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from typing import TypeVar
                from django.db import models
                from django_stubs_ext.db.models import TypedModelMeta

                _T = TypeVar('_T', bound=models.Model)
                class Manager1(models.Manager[_T]):
                    pass
                class Manager2(models.Manager[_T]):
                    pass
                class MyModel(models.Model):
                    class Meta(TypedModelMeta):
                        default_manager_name = 'm2'
                    m1 = Manager1['MyModel']()
                    m2 = Manager2['MyModel']()

-   case: test_leave_as_is_if_objects_is_set_and_fill_typevars_with_outer_class
    main: |
        from typing_extensions import reveal_type
        from myapp.models import MyUser
        reveal_type(MyUser.objects)  # N: Revealed type is "myapp.models.UserManager"
        reveal_type(MyUser.objects.get())  # N: Revealed type is "myapp.models.MyUser"
        reveal_type(MyUser.objects.get_or_404())  # N: Revealed type is "myapp.models.MyUser"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from django.db import models

                class UserManager(models.Manager['MyUser']):
                    def get_or_404(self) -> 'MyUser':
                        pass

                class MyUser(models.Model):
                    objects = UserManager()

-   case: model_imported_from_different_file
    main: |
        from typing_extensions import reveal_type
        from myapp.models import Inventory, Band
        reveal_type(Inventory.objects)  # N: Revealed type is "django.db.models.manager.Manager[myapp.models.main.Inventory]"
        reveal_type(Band.objects)  # N: Revealed type is "django.db.models.manager.Manager[myapp.models.Band]"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models/__init__.py
            content: |
                from django.db import models
                from .main import Inventory as Inventory
                class Band(models.Model):
                    pass
        -   path: myapp/models/main.py
            content: |
                from django.db import models
                class Inventory(models.Model):
                    pass

-   case: managers_that_defined_on_other_models_do_not_influence
    main: |
        from typing_extensions import reveal_type
        from myapp.models import AbstractPerson, Book
        reveal_type(AbstractPerson.abstract_persons)  # N: Revealed type is "django.db.models.manager.Manager[myapp.models.AbstractPerson]"
        reveal_type(Book.published_objects)  # N: Revealed type is "myapp.models.PublishedBookManager"
        Book.published_objects.create(title='hello')
        reveal_type(Book.annotated_objects)  # N: Revealed type is "myapp.models.AnnotatedBookManager"
        Book.annotated_objects.create(title='hello')
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from django.db import models

                class AbstractPerson(models.Model):
                    abstract_persons = models.Manager['AbstractPerson']()
                class PublishedBookManager(models.Manager['Book']):
                    pass
                class AnnotatedBookManager(models.Manager['Book']):
                    pass
                class Book(models.Model):
                    title = models.CharField(max_length=50)
                    published_objects = PublishedBookManager()
                    annotated_objects = AnnotatedBookManager()

-   case: managers_inherited_from_abstract_classes_multiple_inheritance
    main: |
        from typing_extensions import reveal_type
        from myapp.models import AbstractBase1, AbstractBase2, Child
        reveal_type(Child.manager1)
        reveal_type(Child.restricted)
        reveal_type(AbstractBase1.manager1)
        reveal_type(AbstractBase2.restricted)
    out: |
        main:3: note: Revealed type is "myapp.models.CustomManager1"
        main:4: note: Revealed type is "myapp.models.CustomManager2"
        main:5: note: Revealed type is "myapp.models.CustomManager1"
        main:6: note: Revealed type is "myapp.models.CustomManager2"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from django.db import models
                class CustomManager1(models.Manager['AbstractBase1']):
                    pass
                class AbstractBase1(models.Model):
                    class Meta:
                        abstract = True
                    name = models.CharField(max_length=50)
                    manager1 = CustomManager1()
                class CustomManager2(models.Manager['AbstractBase2']):
                    pass
                class AbstractBase2(models.Model):
                    class Meta:
                        abstract = True
                    value = models.CharField(max_length=50)
                    restricted = CustomManager2()

                class Child(AbstractBase1, AbstractBase2):
                    pass

-   case: managers_inherited_from_abstract_classes_multiple_inheritance_with_generic
    main: |
        from typing_extensions import reveal_type
        from myapp.models import AbstractBase1, AbstractBase2, Child
        reveal_type(Child.manager1)  # N: Revealed type is "myapp.models.CustomManager1[myapp.models.Child]"
        reveal_type(Child.manager1.get())  # N: Revealed type is "myapp.models.Child"
        reveal_type(Child.restricted)  # N: Revealed type is "myapp.models.CustomManager2[myapp.models.Child]"
        reveal_type(Child.restricted.get())  # N: Revealed type is "myapp.models.Child"
        reveal_type(AbstractBase1.manager1)  # N: Revealed type is "myapp.models.CustomManager1[myapp.models.AbstractBase1]"
        reveal_type(AbstractBase1.manager1.get())  # N: Revealed type is "myapp.models.AbstractBase1"
        reveal_type(AbstractBase2.restricted)  # N: Revealed type is "myapp.models.CustomManager2[myapp.models.AbstractBase2]"
        reveal_type(AbstractBase2.restricted.get())  # N: Revealed type is "myapp.models.AbstractBase2"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from typing import Generic, TypeVar
                from django.db import models

                T1 = TypeVar("T1", bound="AbstractBase1")
                class CustomManager1(models.Manager[T1], Generic[T1]): ...
                class AbstractBase1(models.Model):
                    class Meta:
                        abstract = True
                    name = models.CharField(max_length=50)
                    manager1 = CustomManager1()

                T2 = TypeVar("T2", bound="AbstractBase2")
                class CustomManager2(models.Manager[T2], Generic[T2]): ...
                class AbstractBase2(models.Model):
                    class Meta:
                        abstract = True
                    value = models.CharField(max_length=50)
                    restricted = CustomManager2()

                class Child(AbstractBase1, AbstractBase2): ...

-   case: model_has_a_manager_of_the_same_type
    main: |
        from typing_extensions import reveal_type
        from myapp.models import UnrelatedModel, MyModel
        reveal_type(UnrelatedModel.objects) # N: Revealed type is "django.db.models.manager.Manager[myapp.models.UnrelatedModel]"
        reveal_type(UnrelatedModel.objects.first()) # N: Revealed type is "myapp.models.UnrelatedModel | None"

        reveal_type(MyModel.objects) # N: Revealed type is "django.db.models.manager.Manager[myapp.models.MyModel]"
        reveal_type(MyModel.objects.first()) # N: Revealed type is "myapp.models.MyModel | None"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from django.db import models
                class UnrelatedModel(models.Model):
                    objects = models.Manager['UnrelatedModel']()

                class MyModel(models.Model):
                    pass

-   case: manager_without_annotation_of_the_model_gets_it_from_outer_one
    main: |
        from typing_extensions import reveal_type
        from myapp.models import UnrelatedModel2, MyModel2
        reveal_type(UnrelatedModel2.objects) # N: Revealed type is "django.db.models.manager.Manager[myapp.models.UnrelatedModel2]"
        reveal_type(UnrelatedModel2.objects.first()) # N: Revealed type is "myapp.models.UnrelatedModel2 | None"

        reveal_type(MyModel2.objects) # N: Revealed type is "django.db.models.manager.Manager[myapp.models.MyModel2]"
        reveal_type(MyModel2.objects.first()) # N: Revealed type is "myapp.models.MyModel2 | None"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from django.db import models
                class UnrelatedModel2(models.Model):
                    objects = models.Manager()

                class MyModel2(models.Model):
                    pass

-   case: inherited_manager_has_the_proper_type_of_model
    main: |
        from typing_extensions import reveal_type
        from myapp.models import ParentOfMyModel3, MyModel3
        reveal_type(ParentOfMyModel3.objects) # N: Revealed type is "django.db.models.manager.Manager[myapp.models.ParentOfMyModel3]"
        reveal_type(ParentOfMyModel3.objects.first()) # N: Revealed type is "myapp.models.ParentOfMyModel3 | None"

        reveal_type(MyModel3.objects) # N: Revealed type is "django.db.models.manager.Manager[myapp.models.MyModel3]"
        reveal_type(MyModel3.objects.first()) # N: Revealed type is "myapp.models.MyModel3 | None"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from django.db import models
                class ParentOfMyModel3(models.Model):
                    objects = models.Manager()

                class MyModel3(ParentOfMyModel3):
                    pass

-   case: inheritance_with_explicit_type_on_child_manager
    main: |
        from typing_extensions import reveal_type
        from myapp.models import ParentOfMyModel4, MyModel4
        reveal_type(ParentOfMyModel4.objects) # N: Revealed type is "django.db.models.manager.Manager[myapp.models.ParentOfMyModel4]"
        reveal_type(ParentOfMyModel4.objects.first()) # N: Revealed type is "myapp.models.ParentOfMyModel4 | None"

        reveal_type(MyModel4.objects) # N: Revealed type is "django.db.models.manager.Manager[myapp.models.MyModel4]"
        reveal_type(MyModel4.objects.first()) # N: Revealed type is "myapp.models.MyModel4 | None"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from typing import ClassVar
                from django.db import models
                class ParentOfMyModel4(models.Model):
                    objects = models.Manager()

                class MyModel4(ParentOfMyModel4):
                    objects: ClassVar[models.Manager["MyModel4"]] = models.Manager["MyModel4"]()

# TODO: make it work someday
#-   case: inheritance_of_two_models_with_custom_objects_manager
#    main: |
#        from typing_extensions import reveal_type
#        from myapp.models import MyBaseUser, MyUser
#        reveal_type(MyBaseUser.objects)  # N: Revealed type is "myapp.models.MyBaseManager[myapp.models.MyBaseUser]"
#        reveal_type(MyBaseUser.objects.get())  # N: Revealed type is "myapp.models.MyBaseUser"
#
#        reveal_type(MyUser.objects)  # N: Revealed type is "myapp.models.MyManager[myapp.models.MyUser]"
#        reveal_type(MyUser.objects.get())  # N: Revealed type is "myapp.models.MyUser"
#    installed_apps:
#        - myapp
#    files:
#        -   path: myapp/__init__.py
#        -   path: myapp/models.py
#            content: |
#                from django.db import models
#
#                class MyBaseManager(models.Manager):
#                    pass
#                class MyBaseUser(models.Model):
#                    objects = MyBaseManager()
#
#                class MyManager(models.Manager):
#                    pass
#                class MyUser(MyBaseUser):
#                    objects = MyManager()

-   case: custom_manager_returns_proper_model_types
    main: |
        from typing_extensions import reveal_type
        from myapp.models import User
        reveal_type(User.objects)  # N: Revealed type is "myapp.models.MyManager[myapp.models.User]"
        reveal_type(User.objects.select_related())  # N: Revealed type is "django.db.models.query.QuerySet[myapp.models.User, myapp.models.User]"
        reveal_type(User.objects.get())  # N: Revealed type is "myapp.models.User"
        reveal_type(User.objects.get_instance())  # N: Revealed type is "builtins.int"
        reveal_type(User.objects.get_instance_untyped('hello'))  # N: Revealed type is "Any"

        from myapp.models import ChildUser
        reveal_type(ChildUser.objects)  # N: Revealed type is "myapp.models.MyManager[myapp.models.ChildUser]"
        reveal_type(ChildUser.objects.select_related())  # N: Revealed type is "django.db.models.query.QuerySet[myapp.models.ChildUser, myapp.models.ChildUser]"
        reveal_type(ChildUser.objects.get())  # N: Revealed type is "myapp.models.ChildUser"
        reveal_type(ChildUser.objects.get_instance())  # N: Revealed type is "builtins.int"
        reveal_type(ChildUser.objects.get_instance_untyped('hello'))  # N: Revealed type is "Any"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from typing import Any
                from django.db import models
                class MyManager(models.Manager):
                    def get_instance(self) -> int:
                        pass
                    def get_instance_untyped(self, name: str):  # type: ignore[no-untyped-def]
                        pass
                class User(models.Model):
                    objects = MyManager()
                class ChildUser(models.Model):
                    objects = MyManager()

-   case: custom_manager_annotate_method_before_type_declaration
    main: |
        from typing_extensions import reveal_type
        from myapp.models import ModelA, ModelB, ManagerA
        reveal_type(ModelA.objects)  # N: Revealed type is "myapp.models.ManagerA[myapp.models.ModelA]"
        reveal_type(ModelA.objects.do_something)  # N: Revealed type is "def (other_obj: myapp.models.ModelB) -> builtins.str"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from django.db import models
                class ManagerA(models.Manager):
                    def do_something(self, other_obj: "ModelB") -> str:
                        return 'test'
                class ModelA(models.Model):
                    title = models.TextField()
                    objects = ManagerA()
                class ModelB(models.Model):
                    movie = models.TextField()


-   case: override_manager_create1
    main: |
        from myapp.models import MyModel
    installed_apps:
        - myapp
    out: |
        myapp/models:5: error: Return type "MyModel" of "create" incompatible with return type "_T" in supertype "django.db.models.manager.Manager"  [override]
        myapp/models:6: error: Incompatible return value type (got "_T", expected "MyModel")  [return-value]
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from typing import Any
                from django.db import models
                class MyModelManager(models.Manager):

                    def create(self, **kwargs: Any) -> 'MyModel':
                        return super().create(**kwargs)


                class MyModel(models.Model):
                    objects = MyModelManager()


-   case: override_manager_create2
    main: |
        from myapp.models import MyModel
        MyModel.objects.create()
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from typing import Any
                from django.db import models
                class MyModelManager(models.Manager['MyModel']):

                    def create(self, **kwargs: Any) -> 'MyModel':
                        return super().create(**kwargs)

                class MyModel(models.Model):
                    objects = MyModelManager()

-   case: regression_manager_scope_foreign
    main: |
        from typing_extensions import reveal_type
        from myapp.models import MyModel
        reveal_type(MyModel.on_site)  # N: Revealed type is "django.contrib.sites.managers.CurrentSiteManager[myapp.models.MyModel]"
    installed_apps:
        - myapp
        - django.contrib.sites
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from django.db import models
                from django.contrib.sites.models import Site
                from django.contrib.sites.managers import CurrentSiteManager

                class MyModel(models.Model):
                    site = models.ForeignKey(Site, on_delete=models.CASCADE)
                    on_site = CurrentSiteManager()

-   case: test_emits_error_for_unresolved_managers
    main: |
        from myapp import models
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from typing_extensions import reveal_type
                from django.db import models

                def LocalManager() -> models.Manager:
                    """
                    Returns a manager instance of an inlined manager type that can't
                    be resolved.
                    """
                    class InnerManager(models.Manager):
                        ...

                    return InnerManager()

                class User(models.Model):
                    name = models.TextField()

                class Booking(models.Model):
                    renter = models.ForeignKey(User, on_delete=models.PROTECT)
                    owner = models.ForeignKey(User, on_delete=models.PROTECT, related_name='bookingowner_set')

                    objects = LocalManager()

                class TwoUnresolvable(models.Model):
                    objects = LocalManager()
                    second_objects = LocalManager()

                class AbstractUnresolvable(models.Model):
                    objects = LocalManager()

                    class Meta:
                        abstract = True

                class InvisibleUnresolvable(AbstractUnresolvable):
                    text = models.TextField()

                def process_booking(user: User) -> None:
                    reveal_type(User.objects)
                    reveal_type(User._default_manager)

                    reveal_type(Booking.objects)
                    reveal_type(Booking._default_manager)

                    reveal_type(TwoUnresolvable.objects)
                    reveal_type(TwoUnresolvable.second_objects)
                    reveal_type(TwoUnresolvable._default_manager)

                    reveal_type(InvisibleUnresolvable.objects)
                    reveal_type(InvisibleUnresolvable._default_manager)

                    reveal_type(user.bookingowner_set)
                    reveal_type(user.booking_set)

                    # Check QuerySet methods on UnknownManager
                    reveal_type(Booking.objects.all)
                    reveal_type(Booking.objects.custom)
                    reveal_type(Booking.objects.all().filter)
                    reveal_type(Booking.objects.all().custom)
                    reveal_type(Booking.objects.first())
                    reveal_type(Booking.objects.get())
                    reveal_type([booking for booking in Booking.objects.all()])
                    reveal_type([booking for booking in Booking.objects.all().filter()])


                    # Check QuerySet methods for unresolvable manager
                    reveal_type(user.booking_set.all)
                    reveal_type(user.booking_set.custom)
                    reveal_type(user.booking_set.all().filter)
                    reveal_type(user.booking_set.all().custom)
                    reveal_type(user.booking_set.all().first())
    out: |
        myapp/models:14: error: Couldn't resolve related manager 'booking_set' for relation 'myapp.models.Booking.renter'.  [django-manager-missing]
        myapp/models:14: error: Couldn't resolve related manager 'bookingowner_set' for relation 'myapp.models.Booking.owner'.  [django-manager-missing]
        myapp/models:21: error: Could not resolve manager type for "myapp.models.Booking.objects"  [django-manager-missing]
        myapp/models:24: error: Could not resolve manager type for "myapp.models.TwoUnresolvable.objects"  [django-manager-missing]
        myapp/models:25: error: Could not resolve manager type for "myapp.models.TwoUnresolvable.second_objects"  [django-manager-missing]
        myapp/models:28: error: Could not resolve manager type for "myapp.models.AbstractUnresolvable.objects"  [django-manager-missing]
        myapp/models:37: note: Revealed type is "django.db.models.manager.Manager[myapp.models.User]"
        myapp/models:38: note: Revealed type is "django.db.models.manager.Manager[myapp.models.User]"
        myapp/models:40: note: Revealed type is "myapp.models.UnknownManager[myapp.models.Booking]"
        myapp/models:41: note: Revealed type is "django.db.models.manager.Manager[myapp.models.Booking]"
        myapp/models:43: note: Revealed type is "myapp.models.UnknownManager[myapp.models.TwoUnresolvable]"
        myapp/models:44: note: Revealed type is "myapp.models.UnknownManager[myapp.models.TwoUnresolvable]"
        myapp/models:45: note: Revealed type is "django.db.models.manager.Manager[myapp.models.TwoUnresolvable]"
        myapp/models:47: note: Revealed type is "myapp.models.UnknownManager[myapp.models.InvisibleUnresolvable]"
        myapp/models:48: note: Revealed type is "django.db.models.manager.Manager[myapp.models.InvisibleUnresolvable]"
        myapp/models:50: note: Revealed type is "django.db.models.fields.related_descriptors.RelatedManager[myapp.models.Booking]"
        myapp/models:51: note: Revealed type is "django.db.models.fields.related_descriptors.RelatedManager[myapp.models.Booking]"
        myapp/models:54: note: Revealed type is "def () -> myapp.models.UnknownQuerySet[myapp.models.Booking, myapp.models.Booking]"
        myapp/models:55: note: Revealed type is "Any"
        myapp/models:56: note: Revealed type is "def (*args: Any, **kwargs: Any) -> myapp.models.UnknownQuerySet[myapp.models.Booking, myapp.models.Booking]"
        myapp/models:57: note: Revealed type is "Any"
        myapp/models:58: note: Revealed type is "myapp.models.Booking | None"
        myapp/models:59: note: Revealed type is "myapp.models.Booking"
        myapp/models:60: note: Revealed type is "builtins.list[myapp.models.Booking]"
        myapp/models:61: note: Revealed type is "builtins.list[myapp.models.Booking]"
        myapp/models:65: note: Revealed type is "def () -> django.db.models.query.QuerySet[myapp.models.Booking, myapp.models.Booking]"
        myapp/models:66: error: "RelatedManager[Booking]" has no attribute "custom"  [attr-defined]
        myapp/models:66: note: Revealed type is "Any"
        myapp/models:67: note: Revealed type is "def (*args: Any, **kwargs: Any) -> django.db.models.query.QuerySet[myapp.models.Booking, myapp.models.Booking]"
        myapp/models:68: error: "QuerySet[Booking, Booking]" has no attribute "custom"  [attr-defined]
        myapp/models:68: note: Revealed type is "Any"
        myapp/models:69: note: Revealed type is "myapp.models.Booking | None"

-   case: subclass_manager_without_type_parameters
    main: |
        from typing_extensions import reveal_type
        from myapp.models import MySubModel
        reveal_type(MySubModel.objects) # N: Revealed type is "myapp.models.MySubManager[myapp.models.MySubModel]"
        reveal_type(MySubModel.objects.get()) # N: Revealed type is "myapp.models.MySubModel"
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from typing import ClassVar, TypeVar
                from typing_extensions import Self
                from django.db import models

                T = TypeVar("T", bound="MyModel")

                class MyManager(models.Manager[T]):
                    pass

                class MySubManager(MyManager):
                    pass

                class MyModel(models.Model):
                    pass

                class MySubModel(MyModel):
                    objects: ClassVar[MySubManager[Self]] = MySubManager()

-   case: subclass_manager_without_type_parameters_disallow_any_generics
    main: |
        from typing_extensions import reveal_type
        from myapp.models import MySubModel
        reveal_type(MySubModel.objects)
        reveal_type(MySubModel.objects.get())
    installed_apps:
        - myapp
    mypy_config: |
        [mypy-myapp.models]
        disallow_any_generics = true
    out: |
        main:3: note: Revealed type is "myapp.models.MySubManager"
        main:4: note: Revealed type is "Any"
        myapp/models:9: error: Missing type parameters for generic type "MyManager"  [type-arg]
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from typing import ClassVar, TypeVar
                from django.db import models

                T = TypeVar("T", bound="MyModel")

                class MyManager(models.Manager[T]):
                    pass

                class MySubManager(MyManager):
                    pass

                class MyModel(models.Model):
                    pass

                class MySubModel(MyModel):
                    objects: ClassVar[MySubManager] = MySubManager()

-   case: nested_manager_class_definition
    main: |
        from typing_extensions import reveal_type
        from myapp.models import MyModel
        reveal_type(MyModel.objects)
        reveal_type(MyModel.objects.get())
    installed_apps:
        - myapp
    out: |
        main:3: note: Revealed type is "myapp.models.MyModel.MyManager[myapp.models.MyModel]"
        main:4: note: Revealed type is "myapp.models.MyModel"
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from typing import Any
                from django.db import models
                class MyModel(models.Model):
                    class MyManager(models.Manager):
                        def get_instance(self) -> int:
                            pass
                    objects = MyManager()

-   case: test_typechecks_filter_methods_of_queryset_type
    main: |
        from myapp.models import MyModel
        MyModel.objects.filter(id=1).filter(invalid=1)  # E: Cannot resolve keyword 'invalid' into field. Choices are: id  [misc]
        MyModel.objects.filter(id=1).get(invalid=1)  # E: Cannot resolve keyword 'invalid' into field. Choices are: id  [misc]
        MyModel.objects.filter(id=1).exclude(invalid=1)  # E: Cannot resolve keyword 'invalid' into field. Choices are: id  [misc]
        MyModel.objects.filter(id=1).create(invalid=1)  # E: Unexpected attribute "invalid" for model "MyModel"  [misc]
    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from django.db import models

                class MyModel(models.Model): ...

-   case: test_does_not_populate_an_unexpected_type_argument
    main: |
        from typing_extensions import reveal_type
        from myapp.models import MyModel
        reveal_type(MyModel.populated_manager)  # N: Revealed type is "myapp.models.PopulatedManager"
        reveal_type(MyModel.populated_manager.get())  # N: Revealed type is "myapp.models.MyModel"
        reveal_type(MyModel.populated_manager.filter())  # N: Revealed type is "django.db.models.query.QuerySet[myapp.models.MyModel, myapp.models.MyModel]"

        reveal_type(MyModel.populated_manager_from_generic_queryset)  # N: Revealed type is "myapp.models.PopulatedManagerFromQuerySet"
        reveal_type(MyModel.populated_manager_from_generic_queryset.get())  # N: Revealed type is "myapp.models.MyModel"
        reveal_type(MyModel.populated_manager_from_generic_queryset.filter())  # N: Revealed type is "django.db.models.query.QuerySet[myapp.models.MyModel, myapp.models.MyModel]"

        reveal_type(MyModel.populated_manager_from_populated_queryset)  # N: Revealed type is "myapp.models.PopulatedManagerFromPopulatedQuerySet"
        reveal_type(MyModel.populated_manager_from_populated_queryset.get())  # N: Revealed type is "myapp.models.MyModel"
        reveal_type(MyModel.populated_manager_from_populated_queryset.filter())  # N: Revealed type is "myapp.models.PopulatedQuerySet"

        reveal_type(MyModel.generic_manager)  # N: Revealed type is "django.db.models.manager.Manager[myapp.models.MyModel]"
        reveal_type(MyModel.generic_manager.get())  # N: Revealed type is "myapp.models.MyModel"
        reveal_type(MyModel.generic_manager.filter())  # N: Revealed type is "django.db.models.query.QuerySet[myapp.models.MyModel, myapp.models.MyModel]"

        reveal_type(MyModel.generic_manager_from_generic_queryset)  # N: Revealed type is "myapp.models.ManagerFromQuerySet[myapp.models.MyModel]"
        reveal_type(MyModel.generic_manager_from_generic_queryset.get())  # N: Revealed type is "myapp.models.MyModel"
        reveal_type(MyModel.generic_manager_from_generic_queryset.filter())  # N: Revealed type is "django.db.models.query.QuerySet[myapp.models.MyModel, myapp.models.MyModel]"

        reveal_type(MyModel.generic_manager_from_populated_queryset)  # N: Revealed type is "myapp.models.ManagerFromPopulatedQuerySet[myapp.models.MyModel]"
        reveal_type(MyModel.generic_manager_from_populated_queryset.get())  # N: Revealed type is "myapp.models.MyModel"
        reveal_type(MyModel.generic_manager_from_populated_queryset.filter())  # N: Revealed type is "myapp.models.PopulatedQuerySet"

    installed_apps:
        - myapp
    files:
        -   path: myapp/__init__.py
        -   path: myapp/models.py
            content: |
                from django.db import models

                class PopulatedManager(models.Manager["MyModel"]): ...
                class PopulatedQuerySet(models.QuerySet["MyModel"]): ...

                PopulatedManagerFromGenericQuerySet = PopulatedManager.from_queryset(models.QuerySet)
                PopulatedManagerFromPopulatedQuerySet = PopulatedManager.from_queryset(PopulatedQuerySet)
                GenericManagerFromGenericQuerySet = models.Manager.from_queryset(models.QuerySet)
                GenericManagerFromPopulatedQuerySet = models.Manager.from_queryset(PopulatedQuerySet)

                class MyModel(models.Model):
                    populated_manager = PopulatedManager()
                    populated_manager_from_generic_queryset = PopulatedManagerFromGenericQuerySet()
                    populated_manager_from_populated_queryset = PopulatedManagerFromPopulatedQuerySet()
                    generic_manager = models.Manager()
                    generic_manager_from_generic_queryset = GenericManagerFromGenericQuerySet()
                    generic_manager_from_populated_queryset = GenericManagerFromPopulatedQuerySet()

# Regression test for #2304
-   case: test_objects_managers_is_kept_with_specific_import_graph
    main: |
        from typing_extensions import reveal_type
        from zerver.models import RealmFilter
        reveal_type(RealmFilter.objects)  # N: Revealed type is "django.db.models.manager.Manager[zerver.models.linkifiers.RealmFilter]"
    installed_apps:
        - django.contrib.auth
        - django.contrib.contenttypes
        - confirmation
        - zerver
    files:
        -   path: confirmation/__init__.py
        -   path: confirmation/models.py
            content: |
                from django.db import models
                from zerver.models import Realm
                class Confirmation(models.Model):
                    realm = models.ForeignKey(Realm, on_delete=models.CASCADE)
        -   path: zerver/__init__.py
        -   path: zerver/models/__init__.py
            content: |
                from zerver.models.linkifiers import RealmFilter as RealmFilter
                from zerver.models.realms import Realm as Realm
                from zerver.models.streams import Stream as Stream
                from zerver.models.users import UserProfile as UserProfile
                RealmFilter.objects
        -   path: zerver/models/linkifiers.py
            content: |
                from django.db import models
                class RealmFilter(models.Model):
                    pass
        -   path: zerver/models/realms.py
            content: |
                from django.db import models
                class Realm(models.Model):
                    pass
        -   path: zerver/models/streams.py
            content: |
                from django.db import models
                from zerver.models.realms import Realm
                from zerver.models.users import UserProfile
                class Stream(models.Model):
                    realm = models.ForeignKey(Realm, on_delete=models.RESTRICT)
                    creator = models.ForeignKey(UserProfile, on_delete=models.RESTRICT)
        -   path: zerver/models/users.py
            content: |
                from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin
                class UserProfile(AbstractBaseUser, PermissionsMixin):
                    pass