sorbet-rails 0.4.0 → 0.5.0

data/spec/test_data/v5.2-no-sorbet/expected_srb_tc_output.txt

@@ -1,11 +1,3 @@
-sorbet_test_cases.rb:14: Argument does not have asserted type `ActiveRecord::Associations::CollectionProxy` https://srb.help/7007
-    14 |T.assert_type!(wizard.spell_books, ActiveRecord::Associations::CollectionProxy)
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  Got SpellBook::ActiveRecord_Associations_CollectionProxy originating from:
-    sorbet_test_cases.rb:14:
-    14 |T.assert_type!(wizard.spell_books, ActiveRecord::Associations::CollectionProxy)
-                       ^^^^^^^^^^^^^^^^^^
-
 sorbet_test_cases.rb:15: Revealed type: `SpellBook::ActiveRecord_Associations_CollectionProxy` https://srb.help/7014
     15 |T.reveal_type(wizard.spell_books) # SpellBook::CollectionProxy
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -14,14 +6,6 @@ sorbet_test_cases.rb:15: Revealed type: `SpellBook::ActiveRecord_Associations_Co
     15 |T.reveal_type(wizard.spell_books) # SpellBook::CollectionProxy
                       ^^^^^^^^^^^^^^^^^^
 
-sorbet_test_cases.rb:19: Argument does not have asserted type `ActiveRecord::Relation` https://srb.help/7007
-    19 |T.assert_type!(Wizard.all, ActiveRecord::Relation)
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  Got Wizard::ActiveRecord_Relation originating from:
-    sorbet_test_cases.rb:19:
-    19 |T.assert_type!(Wizard.all, ActiveRecord::Relation)
-                       ^^^^^^^^^^
-
 sorbet_test_cases.rb:20: Revealed type: `Wizard::ActiveRecord_Relation` https://srb.help/7014
     20 |T.reveal_type(Wizard.all) # Wizard::ActiveRecord_Relation
         ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -30,14 +14,6 @@ sorbet_test_cases.rb:20: Revealed type: `Wizard::ActiveRecord_Relation` https://
     20 |T.reveal_type(Wizard.all) # Wizard::ActiveRecord_Relation
                       ^^^^^^^^^^
 
-sorbet_test_cases.rb:23: Argument does not have asserted type `ActiveRecord::Relation` https://srb.help/7007
-    23 |T.assert_type!(Wizard.recent, ActiveRecord::Relation)
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  Got Wizard::ActiveRecord_Relation originating from:
-    sorbet_test_cases.rb:23:
-    23 |T.assert_type!(Wizard.recent, ActiveRecord::Relation)
-                       ^^^^^^^^^^^^^
-
 sorbet_test_cases.rb:24: Revealed type: `Wizard::ActiveRecord_Relation` https://srb.help/7014
     24 |T.reveal_type(Wizard.recent)
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -46,14 +22,6 @@ sorbet_test_cases.rb:24: Revealed type: `Wizard::ActiveRecord_Relation` https://
     24 |T.reveal_type(Wizard.recent)
                       ^^^^^^^^^^^^^
 
-sorbet_test_cases.rb:27: Argument does not have asserted type `ActiveRecord::Relation` https://srb.help/7007
-    27 |T.assert_type!(Wizard.Gryffindor, ActiveRecord::Relation)
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  Got Wizard::ActiveRecord_Relation originating from:
-    sorbet_test_cases.rb:27:
-    27 |T.assert_type!(Wizard.Gryffindor, ActiveRecord::Relation)
-                       ^^^^^^^^^^^^^^^^^
-
 sorbet_test_cases.rb:28: Revealed type: `Wizard::ActiveRecord_Relation` https://srb.help/7014
     28 |T.reveal_type(Wizard.Gryffindor)
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -62,14 +30,6 @@ sorbet_test_cases.rb:28: Revealed type: `Wizard::ActiveRecord_Relation` https://
     28 |T.reveal_type(Wizard.Gryffindor)
                       ^^^^^^^^^^^^^^^^^
 
-sorbet_test_cases.rb:31: Argument does not have asserted type `ActiveRecord::Relation` https://srb.help/7007
-    31 |T.assert_type!(Wizard.Gryffindor.recent, ActiveRecord::Relation)
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  Got Wizard::ActiveRecord_Relation originating from:
-    sorbet_test_cases.rb:31:
-    31 |T.assert_type!(Wizard.Gryffindor.recent, ActiveRecord::Relation)
-                       ^^^^^^^^^^^^^^^^^^^^^^^^
-
 sorbet_test_cases.rb:32: Revealed type: `Wizard::ActiveRecord_Relation` https://srb.help/7014
     32 |T.reveal_type(Wizard.Gryffindor.recent)
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -78,14 +38,6 @@ sorbet_test_cases.rb:32: Revealed type: `Wizard::ActiveRecord_Relation` https://
     32 |T.reveal_type(Wizard.Gryffindor.recent)
                       ^^^^^^^^^^^^^^^^^^^^^^^^
 
-sorbet_test_cases.rb:33: Argument does not have asserted type `ActiveRecord::Relation` https://srb.help/7007
-    33 |T.assert_type!(Wizard.Gryffindor.recent.unscoped, ActiveRecord::Relation)
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  Got Wizard::ActiveRecord_Relation originating from:
-    sorbet_test_cases.rb:33:
-    33 |T.assert_type!(Wizard.Gryffindor.recent.unscoped, ActiveRecord::Relation)
-                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 sorbet_test_cases.rb:34: Revealed type: `Wizard::ActiveRecord_Relation` https://srb.help/7014
     34 |T.reveal_type(Wizard.Gryffindor.recent.unscoped)
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -94,14 +46,6 @@ sorbet_test_cases.rb:34: Revealed type: `Wizard::ActiveRecord_Relation` https://
     34 |T.reveal_type(Wizard.Gryffindor.recent.unscoped)
                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-sorbet_test_cases.rb:37: Argument does not have asserted type `ActiveRecord::Relation` https://srb.help/7007
-    37 |T.assert_type!(Wizard.where(id: 1), ActiveRecord::Relation)
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  Got Wizard::ActiveRecord_Relation originating from:
-    sorbet_test_cases.rb:37:
-    37 |T.assert_type!(Wizard.where(id: 1), ActiveRecord::Relation)
-                       ^^^^^^^^^^^^^^^^^^^
-
 sorbet_test_cases.rb:38: Revealed type: `Wizard::ActiveRecord_Relation` https://srb.help/7014
     38 |T.reveal_type(Wizard.where(id: 1)) # Wizard::Relation
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -110,14 +54,6 @@ sorbet_test_cases.rb:38: Revealed type: `Wizard::ActiveRecord_Relation` https://
     38 |T.reveal_type(Wizard.where(id: 1)) # Wizard::Relation
                       ^^^^^^^^^^^^^^^^^^^
 
-sorbet_test_cases.rb:39: Argument does not have asserted type `ActiveRecord::Relation` https://srb.help/7007
-    39 |T.assert_type!(Wizard.preload(:spell_books), ActiveRecord::Relation)
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  Got Wizard::ActiveRecord_Relation originating from:
-    sorbet_test_cases.rb:39:
-    39 |T.assert_type!(Wizard.preload(:spell_books), ActiveRecord::Relation)
-                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 sorbet_test_cases.rb:40: Revealed type: `Wizard::ActiveRecord_Relation` https://srb.help/7014
     40 |T.reveal_type(Wizard.preload(:spell_books)) # Wizard::Relation
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -126,14 +62,6 @@ sorbet_test_cases.rb:40: Revealed type: `Wizard::ActiveRecord_Relation` https://
     40 |T.reveal_type(Wizard.preload(:spell_books)) # Wizard::Relation
                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-sorbet_test_cases.rb:41: Argument does not have asserted type `ActiveRecord::Relation` https://srb.help/7007
-    41 |T.assert_type!(Wizard.eager_load(:spell_books), ActiveRecord::Relation)
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  Got Wizard::ActiveRecord_Relation originating from:
-    sorbet_test_cases.rb:41:
-    41 |T.assert_type!(Wizard.eager_load(:spell_books), ActiveRecord::Relation)
-                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 sorbet_test_cases.rb:42: Revealed type: `Wizard::ActiveRecord_Relation` https://srb.help/7014
     42 |T.reveal_type(Wizard.eager_load(:spell_books)) # Wizard::Relation
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -142,14 +70,6 @@ sorbet_test_cases.rb:42: Revealed type: `Wizard::ActiveRecord_Relation` https://
     42 |T.reveal_type(Wizard.eager_load(:spell_books)) # Wizard::Relation
                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-sorbet_test_cases.rb:43: Argument does not have asserted type `ActiveRecord::Relation` https://srb.help/7007
-    43 |T.assert_type!(Wizard.order(:id), ActiveRecord::Relation)
-        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  Got Wizard::ActiveRecord_Relation originating from:
-    sorbet_test_cases.rb:43:
-    43 |T.assert_type!(Wizard.order(:id), ActiveRecord::Relation)
-                       ^^^^^^^^^^^^^^^^^
-
 sorbet_test_cases.rb:44: Revealed type: `Wizard::ActiveRecord_Relation` https://srb.help/7014
     44 |T.reveal_type(Wizard.order(:id)) # Wizard::Relation
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -157,4 +77,4 @@ sorbet_test_cases.rb:44: Revealed type: `Wizard::ActiveRecord_Relation` https://
     sorbet_test_cases.rb:44:
     44 |T.reveal_type(Wizard.order(:id)) # Wizard::Relation
                       ^^^^^^^^^^^^^^^^^
-Errors: 20
+Errors: 10

data/spec/test_data/v5.2-no-sorbet/expected_wand.rbi

@@ -1,216 +1,288 @@
 # This is an autogenerated file for dynamic methods in Wand
-# Please rerun rake rails_rbi:models to regenerate.
+# Please rerun rake rails_rbi:models[Wand] to regenerate.
+
 # typed: strong
+module Wand::EnumInstanceMethods
+  extend T::Sig
 
-class Wand::ActiveRecord_Relation < ActiveRecord::Relation
-  include Wand::ModelRelationShared
-  extend T::Generic
-  Elem = type_member(fixed: Wand)
-end
+  sig { returns(T::Boolean) }
+  def phoenix_feather?; end
 
-class Wand::ActiveRecord_Associations_CollectionProxy < ActiveRecord::Associations::CollectionProxy
-  include Wand::ModelRelationShared
-  extend T::Generic
-  Elem = type_member(fixed: Wand)
-end
+  sig { void }
+  def phoenix_feather!; end
 
-class Wand < ApplicationRecord
-  extend T::Sig
-  extend T::Generic
-  extend Wand::ModelRelationShared
-  include Wand::InstanceMethods
-  Elem = type_template(fixed: Wand)
-end
+  sig { returns(T::Boolean) }
+  def dragon_heartstring?; end
 
-module Wand::InstanceMethods
-  extend T::Sig
+  sig { void }
+  def dragon_heartstring!; end
+
+  sig { returns(T::Boolean) }
+  def unicorn_tail_hair?; end
 
   sig { void }
-  def basilisk_horn!(); end
+  def unicorn_tail_hair!; end
 
   sig { returns(T::Boolean) }
-  def basilisk_horn?(); end
+  def basilisk_horn?; end
+
+  sig { void }
+  def basilisk_horn!; end
+end
+
+module Wand::ActiveRelation_WhereNot
+  sig { params(opts: T.untyped, rest: T.untyped).returns(T.self_type) }
+  def not(opts, *rest); end
+end
+
+module Wand::GeneratedAttributeMethods
+  extend T::Sig
 
   sig { returns(T::Boolean) }
-  def broken(); end
+  def broken; end
 
   sig { params(value: T::Boolean).void }
   def broken=(value); end
 
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def broken?(*args); end
+  sig { returns(T::Boolean) }
+  def broken?; end
 
   sig { returns(T.nilable(Date)) }
-  def chosen_at_date(); end
+  def chosen_at_date; end
 
   sig { params(value: T.nilable(Date)).void }
   def chosen_at_date=(value); end
 
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def chosen_at_date?(*args); end
+  sig { returns(T::Boolean) }
+  def chosen_at_date?; end
 
   sig { returns(T.nilable(Time)) }
-  def chosen_at_time(); end
+  def chosen_at_time; end
 
   sig { params(value: T.nilable(Time)).void }
   def chosen_at_time=(value); end
 
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def chosen_at_time?(*args); end
+  sig { returns(T::Boolean) }
+  def chosen_at_time?; end
 
-  sig { returns(String) }
-  def core_type(); end
+  sig { returns(T.nilable(String)) }
+  def core_type; end
 
   sig { params(value: T.nilable(T.any(Integer, String, Symbol))).void }
   def core_type=(value); end
 
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def core_type?(*args); end
+  sig { returns(T::Boolean) }
+  def core_type?; end
 
   sig { returns(DateTime) }
-  def created_at(); end
+  def created_at; end
 
   sig { params(value: DateTime).void }
   def created_at=(value); end
 
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def created_at?(*args); end
-
-  sig { void }
-  def dragon_heartstring!(); end
-
   sig { returns(T::Boolean) }
-  def dragon_heartstring?(); end
+  def created_at?; end
 
   sig { returns(Float) }
-  def flexibility(); end
+  def flexibility; end
 
   sig { params(value: Float).void }
   def flexibility=(value); end
 
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def flexibility?(*args); end
+  sig { returns(T::Boolean) }
+  def flexibility?; end
 
   sig { returns(BigDecimal) }
-  def hardness(); end
+  def hardness; end
 
   sig { params(value: BigDecimal).void }
   def hardness=(value); end
 
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def hardness?(*args); end
+  sig { returns(T::Boolean) }
+  def hardness?; end
 
   sig { returns(Integer) }
-  def id(); end
+  def id; end
 
   sig { params(value: Integer).void }
   def id=(value); end
 
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def id?(*args); end
+  sig { returns(T::Boolean) }
+  def id?; end
 
-  sig { returns(T.any(Array, T::Boolean, Float, Hash, Integer, String)) }
-  def maker_info(); end
+  sig { returns(T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String)) }
+  def maker_info; end
 
-  sig { params(value: T.any(Array, T::Boolean, Float, Hash, Integer, String)).void }
+  sig { params(value: T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String)).void }
   def maker_info=(value); end
 
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def maker_info?(*args); end
-
-  sig { void }
-  def phoenix_feather!(); end
-
   sig { returns(T::Boolean) }
-  def phoenix_feather?(); end
+  def maker_info?; end
 
   sig { returns(Integer) }
-  def reflectance(); end
+  def reflectance; end
 
   sig { params(value: Integer).void }
   def reflectance=(value); end
 
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def reflectance?(*args); end
+  sig { returns(T::Boolean) }
+  def reflectance?; end
 
-  sig { returns(T.nilable(T.any(Array, T::Boolean, Float, Hash, Integer, String))) }
-  def spell_history(); end
+  sig { returns(T.nilable(T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String))) }
+  def spell_history; end
 
-  sig { params(value: T.nilable(T.any(Array, T::Boolean, Float, Hash, Integer, String))).void }
+  sig { params(value: T.nilable(T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String))).void }
   def spell_history=(value); end
 
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def spell_history?(*args); end
-
-  sig { void }
-  def unicorn_tail_hair!(); end
-
   sig { returns(T::Boolean) }
-  def unicorn_tail_hair?(); end
+  def spell_history?; end
 
   sig { returns(DateTime) }
-  def updated_at(); end
+  def updated_at; end
 
   sig { params(value: DateTime).void }
   def updated_at=(value); end
 
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def updated_at?(*args); end
+  sig { returns(T::Boolean) }
+  def updated_at?; end
 
   sig { returns(Integer) }
-  def wizard_id(); end
+  def wizard_id; end
 
   sig { params(value: Integer).void }
   def wizard_id=(value); end
 
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def wizard_id?(*args); end
+  sig { returns(T::Boolean) }
+  def wizard_id?; end
 
   sig { returns(T.nilable(String)) }
-  def wood_type(); end
+  def wood_type; end
 
   sig { params(value: T.nilable(String)).void }
   def wood_type=(value); end
 
-  sig { params(args: T.untyped).returns(T::Boolean) }
-  def wood_type?(*args); end
-
+  sig { returns(T::Boolean) }
+  def wood_type?; end
 end
 
-class Wand
+module Wand::GeneratedAssociationMethods
   extend T::Sig
 
   sig { returns(::Wizard) }
-  def wizard(); end
+  def wizard; end
 
   sig { params(value: ::Wizard).void }
   def wizard=(value); end
+end
 
-  sig { params(args: T.untyped).returns(Wand::ActiveRecord_Relation) }
-  def self.basilisk_horn(*args); end
-
-  sig { returns(T::Hash[T.any(String, Symbol), Integer]) }
-  def self.core_types(); end
+module Wand::CustomFinderMethods
+  sig { params(limit: Integer).returns(T::Array[Wand]) }
+  def first_n(limit); end
 
-  sig { params(args: T.untyped).returns(Wand::ActiveRecord_Relation) }
-  def self.dragon_heartstring(*args); end
+  sig { params(limit: Integer).returns(T::Array[Wand]) }
+  def last_n(limit); end
 
-  sig { params(args: T.untyped).returns(Wand::ActiveRecord_Relation) }
-  def self.phoenix_feather(*args); end
+  sig { params(args: T::Array[T.any(Integer, String)]).returns(T::Array[Wand]) }
+  def find_n(*args); end
 
-  sig { params(args: T.untyped).returns(Wand::ActiveRecord_Relation) }
-  def self.unicorn_tail_hair(*args); end
+  sig { params(id: Integer).returns(T.nilable(Wand)) }
+  def find_by_id(id); end
 
+  sig { params(id: Integer).returns(Wand) }
+  def find_by_id!(id); end
 end
 
-module Wand::ModelRelationShared
+class Wand < ApplicationRecord
+  include Wand::EnumInstanceMethods
+  include Wand::GeneratedAttributeMethods
+  include Wand::GeneratedAssociationMethods
+  extend SorbetRails::CustomFinderMethods
+  extend Wand::CustomFinderMethods
   extend T::Sig
+  extend T::Generic
+  extend Wand::ModelRelationShared
+
+  sig { returns(T::Hash[T.any(String, Symbol), Integer]) }
+  def self.core_types; end
 
   sig { returns(Wand::ActiveRecord_Relation) }
-  def all(); end
+  def self.phoenix_feather; end
 
-  sig { params(block: T.nilable(T.proc.void)).returns(Wand::ActiveRecord_Relation) }
-  def unscoped(&block); end
+  sig { returns(Wand::ActiveRecord_Relation) }
+  def self.dragon_heartstring; end
+
+  sig { returns(Wand::ActiveRecord_Relation) }
+  def self.unicorn_tail_hair; end
+
+  sig { returns(Wand::ActiveRecord_Relation) }
+  def self.basilisk_horn; end
+
+  sig { params(args: T.untyped).returns(Wand) }
+  def self.find(*args); end
+
+  sig { params(args: T.untyped).returns(T.nilable(Wand)) }
+  def self.find_by(*args); end
+
+  sig { params(args: T.untyped).returns(Wand) }
+  def self.find_by!(*args); end
+
+  sig { returns(T.nilable(Wand)) }
+  def self.first; end
+
+  sig { returns(Wand) }
+  def self.first!; end
+
+  sig { returns(T.nilable(Wand)) }
+  def self.second; end
+
+  sig { returns(Wand) }
+  def self.second!; end
+
+  sig { returns(T.nilable(Wand)) }
+  def self.third; end
+
+  sig { returns(Wand) }
+  def self.third!; end
+
+  sig { returns(T.nilable(Wand)) }
+  def self.third_to_last; end
+
+  sig { returns(Wand) }
+  def self.third_to_last!; end
+
+  sig { returns(T.nilable(Wand)) }
+  def self.second_to_last; end
+
+  sig { returns(Wand) }
+  def self.second_to_last!; end
+
+  sig { returns(T.nilable(Wand)) }
+  def self.last; end
+
+  sig { returns(Wand) }
+  def self.last!; end
+
+  sig { params(conditions: T.untyped).returns(T::Boolean) }
+  def self.exists?(conditions = nil); end
+
+  sig { params(args: T.untyped).returns(T::Boolean) }
+  def self.any?(*args); end
+
+  sig { params(args: T.untyped).returns(T::Boolean) }
+  def self.many?(*args); end
+
+  sig { params(args: T.untyped).returns(T::Boolean) }
+  def self.none?(*args); end
+
+  sig { params(args: T.untyped).returns(T::Boolean) }
+  def self.one?(*args); end
+
+  sig { returns(T::Array[Wand]) }
+  def self.mythicals; end
+end
+
+module Wand::ModelRelationShared
+  extend T::Sig
 
   sig { params(args: T.untyped).returns(Wand::ActiveRecord_Relation) }
   def basilisk_horn(*args); end
@@ -227,6 +299,12 @@ module Wand::ModelRelationShared
   sig { params(args: T.untyped).returns(Wand::ActiveRecord_Relation) }
   def unicorn_tail_hair(*args); end
 
+  sig { returns(Wand::ActiveRecord_Relation) }
+  def all; end
+
+  sig { params(block: T.nilable(T.proc.void)).returns(Wand::ActiveRecord_Relation) }
+  def unscoped(&block); end
+
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(Wand::ActiveRecord_Relation) }
   def select(*args, &block); end
 
@@ -307,5 +385,176 @@ module Wand::ModelRelationShared
 
   sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(Wand::ActiveRecord_Relation) }
   def except(*args, &block); end
+end
+
+class Wand::ActiveRecord_Relation < ActiveRecord::Relation
+  include Wand::ActiveRelation_WhereNot
+  include SorbetRails::CustomFinderMethods
+  include Wand::CustomFinderMethods
+  include Enumerable
+  include Wand::ModelRelationShared
+  extend T::Sig
+  extend T::Generic
+  Elem = type_member(fixed: Wand)
+
+  sig { params(args: T.untyped).returns(Wand) }
+  def find(*args); end
+
+  sig { params(args: T.untyped).returns(T.nilable(Wand)) }
+  def find_by(*args); end
+
+  sig { params(args: T.untyped).returns(Wand) }
+  def find_by!(*args); end
+
+  sig { returns(T.nilable(Wand)) }
+  def first; end
+
+  sig { returns(Wand) }
+  def first!; end
+
+  sig { returns(T.nilable(Wand)) }
+  def second; end
+
+  sig { returns(Wand) }
+  def second!; end
+
+  sig { returns(T.nilable(Wand)) }
+  def third; end
+
+  sig { returns(Wand) }
+  def third!; end
+
+  sig { returns(T.nilable(Wand)) }
+  def third_to_last; end
+
+  sig { returns(Wand) }
+  def third_to_last!; end
+
+  sig { returns(T.nilable(Wand)) }
+  def second_to_last; end
+
+  sig { returns(Wand) }
+  def second_to_last!; end
+
+  sig { returns(T.nilable(Wand)) }
+  def last; end
+
+  sig { returns(Wand) }
+  def last!; end
+
+  sig { params(conditions: T.untyped).returns(T::Boolean) }
+  def exists?(conditions = nil); end
+
+  sig { params(args: T.untyped).returns(T::Boolean) }
+  def any?(*args); end
+
+  sig { params(args: T.untyped).returns(T::Boolean) }
+  def many?(*args); end
+
+  sig { params(args: T.untyped).returns(T::Boolean) }
+  def none?(*args); end
+
+  sig { params(args: T.untyped).returns(T::Boolean) }
+  def one?(*args); end
+
+  sig { implementation.params(block: T.proc.params(e: Wand).void).void }
+  def each(&block); end
+
+  sig { params(level: T.nilable(Integer)).returns(T::Array[Wand]) }
+  def flatten(level); end
+
+  sig { returns(T::Array[Wand]) }
+  def to_a; end
+end
+
+class Wand::ActiveRecord_Associations_CollectionProxy < ActiveRecord::Associations::CollectionProxy
+  include Wand::ActiveRelation_WhereNot
+  include SorbetRails::CustomFinderMethods
+  include Wand::CustomFinderMethods
+  include Enumerable
+  include Wand::ModelRelationShared
+  extend T::Sig
+  extend T::Generic
+  Elem = type_member(fixed: Wand)
+
+  sig { params(args: T.untyped).returns(Wand) }
+  def find(*args); end
+
+  sig { params(args: T.untyped).returns(T.nilable(Wand)) }
+  def find_by(*args); end
+
+  sig { params(args: T.untyped).returns(Wand) }
+  def find_by!(*args); end
+
+  sig { returns(T.nilable(Wand)) }
+  def first; end
+
+  sig { returns(Wand) }
+  def first!; end
+
+  sig { returns(T.nilable(Wand)) }
+  def second; end
+
+  sig { returns(Wand) }
+  def second!; end
+
+  sig { returns(T.nilable(Wand)) }
+  def third; end
+
+  sig { returns(Wand) }
+  def third!; end
+
+  sig { returns(T.nilable(Wand)) }
+  def third_to_last; end
+
+  sig { returns(Wand) }
+  def third_to_last!; end
+
+  sig { returns(T.nilable(Wand)) }
+  def second_to_last; end
+
+  sig { returns(Wand) }
+  def second_to_last!; end
+
+  sig { returns(T.nilable(Wand)) }
+  def last; end
+
+  sig { returns(Wand) }
+  def last!; end
+
+  sig { params(conditions: T.untyped).returns(T::Boolean) }
+  def exists?(conditions = nil); end
+
+  sig { params(args: T.untyped).returns(T::Boolean) }
+  def any?(*args); end
+
+  sig { params(args: T.untyped).returns(T::Boolean) }
+  def many?(*args); end
+
+  sig { params(args: T.untyped).returns(T::Boolean) }
+  def none?(*args); end
+
+  sig { params(args: T.untyped).returns(T::Boolean) }
+  def one?(*args); end
+
+  sig { implementation.params(block: T.proc.params(e: Wand).void).void }
+  def each(&block); end
+
+  sig { params(level: T.nilable(Integer)).returns(T::Array[Wand]) }
+  def flatten(level); end
+
+  sig { returns(T::Array[Wand]) }
+  def to_a; end
+
+  sig { params(records: T.any(Wand, T::Array[Wand])).returns(T.self_type) }
+  def <<(*records); end
+
+  sig { params(records: T.any(Wand, T::Array[Wand])).returns(T.self_type) }
+  def append(*records); end
+
+  sig { params(records: T.any(Wand, T::Array[Wand])).returns(T.self_type) }
+  def push(*records); end
 
+  sig { params(records: T.any(Wand, T::Array[Wand])).returns(T.self_type) }
+  def concat(*records); end
 end