acts-as-messageable 0.5.0 → 1.0.0

data/sorbet/rbi/models/acts-as-messageable/user.rbi

@@ -0,0 +1,343 @@
+# This is an autogenerated file for dynamic methods in CustomSearchUser
+# Please rerun bundle exec rake rails_rbi:models[CustomSearchUser] to regenerate.
+
+# typed: strong
+module CustomSearchUser::ActiveRelation_WhereNot
+  sig { params(opts: T.untyped, rest: T.untyped).returns(T.self_type) }
+  def not(opts, *rest); end
+end
+
+module CustomSearchUser::GeneratedAttributeMethods
+  sig { returns(T.nilable(String)) }
+  def email; end
+
+  sig { params(value: T.nilable(T.any(String, Symbol))).void }
+  def email=(value); end
+
+  sig { returns(T::Boolean) }
+  def email?; end
+
+  sig { returns(Integer) }
+  def id; end
+
+  sig { params(value: T.any(Numeric, ActiveSupport::Duration)).void }
+  def id=(value); end
+
+  sig { returns(T::Boolean) }
+  def id?; end
+end
+
+module CustomSearchUser::GeneratedAssociationMethods
+  sig { returns(ActiveRecord::Associations::CollectionProxy) }
+  def received_messages_relation; end
+
+  sig { params(value: T::Enumerable[T.untyped]).void }
+  def received_messages_relation=(value); end
+
+  sig { returns(ActiveRecord::Associations::CollectionProxy) }
+  def sent_messages_relation; end
+
+  sig { params(value: T::Enumerable[T.untyped]).void }
+  def sent_messages_relation=(value); end
+end
+
+module CustomSearchUser::CustomFinderMethods
+  sig { params(limit: Integer).returns(T::Array[CustomSearchUser]) }
+  def first_n(limit); end
+
+  sig { params(limit: Integer).returns(T::Array[CustomSearchUser]) }
+  def last_n(limit); end
+
+  sig { params(args: T::Array[T.any(Integer, String)]).returns(T::Array[CustomSearchUser]) }
+  def find_n(*args); end
+
+  sig { params(id: T.nilable(Integer)).returns(T.nilable(CustomSearchUser)) }
+  def find_by_id(id); end
+
+  sig { params(id: Integer).returns(CustomSearchUser) }
+  def find_by_id!(id); end
+end
+
+class CustomSearchUser < ActiveRecord::Base
+  include CustomSearchUser::GeneratedAttributeMethods
+  include CustomSearchUser::GeneratedAssociationMethods
+  extend CustomSearchUser::CustomFinderMethods
+  extend CustomSearchUser::QueryMethodsReturningRelation
+  RelationType = T.type_alias { T.any(CustomSearchUser::ActiveRecord_Relation, CustomSearchUser::ActiveRecord_Associations_CollectionProxy, CustomSearchUser::ActiveRecord_AssociationRelation) }
+end
+
+module CustomSearchUser::QueryMethodsReturningRelation
+  sig { returns(CustomSearchUser::ActiveRecord_Relation) }
+  def all; end
+
+  sig { params(block: T.nilable(T.proc.void)).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def unscoped(&block); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def reselect(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def order(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def reorder(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def group(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def limit(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def offset(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def joins(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def left_joins(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def left_outer_joins(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def where(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def rewhere(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def preload(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def extract_associated(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def eager_load(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def includes(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def from(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def lock(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def readonly(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def or(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def having(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def create_with(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def distinct(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def references(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def none(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def unscope(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def optimizer_hints(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def merge(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def except(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def only(*args); end
+
+  sig { params(block: T.proc.params(e: CustomSearchUser).returns(T::Boolean)).returns(T::Array[CustomSearchUser]) }
+  def select(&block); end
+
+  sig { params(args: T.any(String, Symbol, T::Array[T.any(String, Symbol)])).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def select_columns(*args); end
+
+  sig { params(args: Symbol).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def where_missing(*args); end
+
+  sig { params(column: Symbol, values: T::Array[T.untyped]).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def in_order_of(column, values); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def extending(*args, &block); end
+
+  sig do
+    params(
+      of: T.nilable(Integer),
+      start: T.nilable(Integer),
+      finish: T.nilable(Integer),
+      load: T.nilable(T::Boolean),
+      error_on_ignore: T.nilable(T::Boolean),
+      block: T.nilable(T.proc.params(e: CustomSearchUser::ActiveRecord_Relation).void)
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
+  end
+  def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
+end
+
+module CustomSearchUser::QueryMethodsReturningAssociationRelation
+  sig { returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def all; end
+
+  sig { params(block: T.nilable(T.proc.void)).returns(CustomSearchUser::ActiveRecord_Relation) }
+  def unscoped(&block); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def reselect(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def order(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def reorder(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def group(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def limit(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def offset(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def joins(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def left_joins(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def left_outer_joins(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def where(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def rewhere(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def preload(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def extract_associated(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def eager_load(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def includes(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def from(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def lock(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def readonly(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def or(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def having(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def create_with(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def distinct(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def references(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def none(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def unscope(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def optimizer_hints(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def merge(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def except(*args); end
+
+  sig { params(args: T.untyped).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def only(*args); end
+
+  sig { params(block: T.proc.params(e: CustomSearchUser).returns(T::Boolean)).returns(T::Array[CustomSearchUser]) }
+  def select(&block); end
+
+  sig { params(args: T.any(String, Symbol, T::Array[T.any(String, Symbol)])).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def select_columns(*args); end
+
+  sig { params(args: Symbol).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def where_missing(*args); end
+
+  sig { params(column: Symbol, values: T::Array[T.untyped]).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def in_order_of(column, values); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(CustomSearchUser::ActiveRecord_AssociationRelation) }
+  def extending(*args, &block); end
+
+  sig do
+    params(
+      of: T.nilable(Integer),
+      start: T.nilable(Integer),
+      finish: T.nilable(Integer),
+      load: T.nilable(T::Boolean),
+      error_on_ignore: T.nilable(T::Boolean),
+      block: T.nilable(T.proc.params(e: CustomSearchUser::ActiveRecord_AssociationRelation).void)
+    ).returns(ActiveRecord::Batches::BatchEnumerator)
+  end
+  def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, &block); end
+end
+
+class CustomSearchUser::ActiveRecord_Relation < ActiveRecord::Relation
+  include CustomSearchUser::ActiveRelation_WhereNot
+  include CustomSearchUser::CustomFinderMethods
+  include CustomSearchUser::QueryMethodsReturningRelation
+  Elem = type_member {{fixed: CustomSearchUser}}
+end
+
+class CustomSearchUser::ActiveRecord_AssociationRelation < ActiveRecord::AssociationRelation
+  include CustomSearchUser::ActiveRelation_WhereNot
+  include CustomSearchUser::CustomFinderMethods
+  include CustomSearchUser::QueryMethodsReturningAssociationRelation
+  Elem = type_member {{fixed: CustomSearchUser}}
+end
+
+class CustomSearchUser::ActiveRecord_Associations_CollectionProxy < ActiveRecord::Associations::CollectionProxy
+  include CustomSearchUser::CustomFinderMethods
+  include CustomSearchUser::QueryMethodsReturningAssociationRelation
+  Elem = type_member {{fixed: CustomSearchUser}}
+
+  sig { params(records: T.any(CustomSearchUser, T::Array[CustomSearchUser])).returns(T.self_type) }
+  def <<(*records); end
+
+  sig { params(records: T.any(CustomSearchUser, T::Array[CustomSearchUser])).returns(T.self_type) }
+  def append(*records); end
+
+  sig { params(records: T.any(CustomSearchUser, T::Array[CustomSearchUser])).returns(T.self_type) }
+  def push(*records); end
+
+  sig { params(records: T.any(CustomSearchUser, T::Array[CustomSearchUser])).returns(T.self_type) }
+  def concat(*records); end
+end

data/sorbet/rbi/rails-rbi/active_record_base.rbi

@@ -0,0 +1,119 @@
+# typed: strong
+# This is an autogenerated file for Rails' ActiveRecord.
+# Please rerun bundle exec rake rails_rbi:active_record to regenerate.
+class ActiveRecord::Base
+  sig { params(args: T.untyped).returns(T.attached_class) }
+  def self.find(*args); end
+
+  sig { params(args: T.untyped).returns(T.nilable(T.attached_class)) }
+  def self.find_by(*args); end
+
+  sig { params(args: T.untyped).returns(T.attached_class) }
+  def self.find_by!(*args); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: T.attached_class).void)).returns(T.attached_class) }
+  def self.find_or_initialize_by(attributes, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: T.attached_class).void)).returns(T.attached_class) }
+  def self.find_or_create_by(attributes, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: T.attached_class).void)).returns(T.attached_class) }
+  def self.find_or_create_by!(attributes, &block); end
+
+  sig { returns(T.nilable(T.attached_class)) }
+  def self.first; end
+
+  sig { returns(T.attached_class) }
+  def self.first!; end
+
+  sig { returns(T.nilable(T.attached_class)) }
+  def self.second; end
+
+  sig { returns(T.attached_class) }
+  def self.second!; end
+
+  sig { returns(T.nilable(T.attached_class)) }
+  def self.third; end
+
+  sig { returns(T.attached_class) }
+  def self.third!; end
+
+  sig { returns(T.nilable(T.attached_class)) }
+  def self.third_to_last; end
+
+  sig { returns(T.attached_class) }
+  def self.third_to_last!; end
+
+  sig { returns(T.nilable(T.attached_class)) }
+  def self.second_to_last; end
+
+  sig { returns(T.attached_class) }
+  def self.second_to_last!; end
+
+  sig { returns(T.nilable(T.attached_class)) }
+  def self.last; end
+
+  sig { returns(T.attached_class) }
+  def self.last!; end
+
+  sig { returns(T.nilable(T.attached_class)) }
+  def self.take; end
+
+  sig { returns(T.attached_class) }
+  def self.take!; end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: T.attached_class).void)).returns(T.attached_class) }
+  def self.create(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: T.attached_class).void)).returns(T.attached_class) }
+  def self.create!(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: T.attached_class).void)).returns(T.attached_class) }
+  def self.new(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: T.attached_class).void)).returns(T.attached_class) }
+  def self.first_or_create(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: T.attached_class).void)).returns(T.attached_class) }
+  def self.first_or_create!(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: T.attached_class).void)).returns(T.attached_class) }
+  def self.first_or_initialize(attributes = nil, &block); end
+
+  sig do
+    params(
+      start: T.nilable(Integer),
+      finish: T.nilable(Integer),
+      batch_size: T.nilable(Integer),
+      error_on_ignore: T.nilable(T::Boolean),
+      block: T.nilable(T.proc.params(e: T.attached_class).void)
+    ).returns(T::Enumerator[T.attached_class])
+  end
+  def self.find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, &block); end
+
+  sig do
+    params(
+      start: T.nilable(Integer),
+      finish: T.nilable(Integer),
+      batch_size: T.nilable(Integer),
+      error_on_ignore: T.nilable(T::Boolean),
+      block: T.nilable(T.proc.params(e: T::Array[T.attached_class]).void)
+    ).returns(T::Enumerator[T::Array[T.attached_class]])
+  end
+  def self.find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, &block); end
+
+  sig { params(block: T.nilable(T.proc.params(e: T.attached_class).returns(T.nilable(T::Boolean)))).returns(T::Boolean) }
+  def self.any?(&block); end
+
+  sig { params(block: T.nilable(T.proc.params(e: T.attached_class).returns(T.nilable(T::Boolean)))).returns(T::Boolean) }
+  def self.many?(&block); end
+
+  sig { params(block: T.nilable(T.proc.params(e: T.attached_class).returns(T.nilable(T::Boolean)))).returns(T::Boolean) }
+  def self.none?(&block); end
+
+  sig { params(block: T.nilable(T.proc.params(e: T.attached_class).returns(T.nilable(T::Boolean)))).returns(T::Boolean) }
+  def self.one?(&block); end
+
+  sig { params(conditions: T.untyped).returns(T::Boolean) }
+  def self.exists?(conditions = nil); end
+end

data/sorbet/rbi/rails-rbi/active_record_relation.rbi

@@ -0,0 +1,180 @@
+# typed: strong
+# This is an autogenerated file for Rails' ActiveRecord.
+# Please rerun bundle exec rake rails_rbi:active_record to regenerate.
+class ActiveRecord::Relation
+  include Enumerable
+
+  sig { params(args: T.untyped).returns(Elem) }
+  def find(*args); end
+
+  sig { params(args: T.untyped).returns(T.nilable(Elem)) }
+  def find_by(*args); end
+
+  sig { params(args: T.untyped).returns(Elem) }
+  def find_by!(*args); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def find_or_initialize_by(attributes, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def find_or_create_by(attributes, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def find_or_create_by!(attributes, &block); end
+
+  sig { returns(T.nilable(Elem)) }
+  def first; end
+
+  sig { returns(Elem) }
+  def first!; end
+
+  sig { returns(T.nilable(Elem)) }
+  def second; end
+
+  sig { returns(Elem) }
+  def second!; end
+
+  sig { returns(T.nilable(Elem)) }
+  def third; end
+
+  sig { returns(Elem) }
+  def third!; end
+
+  sig { returns(T.nilable(Elem)) }
+  def third_to_last; end
+
+  sig { returns(Elem) }
+  def third_to_last!; end
+
+  sig { returns(T.nilable(Elem)) }
+  def second_to_last; end
+
+  sig { returns(Elem) }
+  def second_to_last!; end
+
+  sig { returns(T.nilable(Elem)) }
+  def last; end
+
+  sig { returns(Elem) }
+  def last!; end
+
+  sig { returns(T.nilable(Elem)) }
+  def take; end
+
+  sig { returns(Elem) }
+  def take!; end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def create(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def create!(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def new(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def build(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def first_or_create(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def first_or_create!(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def first_or_initialize(attributes = nil, &block); end
+
+  sig do
+    params(
+      start: T.nilable(Integer),
+      finish: T.nilable(Integer),
+      batch_size: T.nilable(Integer),
+      error_on_ignore: T.nilable(T::Boolean),
+      block: T.nilable(T.proc.params(e: Elem).void)
+    ).returns(T::Enumerator[Elem])
+  end
+  def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, &block); end
+
+  sig do
+    params(
+      start: T.nilable(Integer),
+      finish: T.nilable(Integer),
+      batch_size: T.nilable(Integer),
+      error_on_ignore: T.nilable(T::Boolean),
+      block: T.nilable(T.proc.params(e: T::Array[Elem]).void)
+    ).returns(T::Enumerator[T::Array[Elem]])
+  end
+  def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, &block); end
+
+  sig { params(block: T.nilable(T.proc.params(e: Elem).returns(T.nilable(T::Boolean)))).returns(T::Boolean) }
+  def any?(&block); end
+
+  sig { params(block: T.nilable(T.proc.params(e: Elem).returns(T.nilable(T::Boolean)))).returns(T::Boolean) }
+  def many?(&block); end
+
+  sig { params(block: T.nilable(T.proc.params(e: Elem).returns(T.nilable(T::Boolean)))).returns(T::Boolean) }
+  def none?(&block); end
+
+  sig { params(block: T.nilable(T.proc.params(e: Elem).returns(T.nilable(T::Boolean)))).returns(T::Boolean) }
+  def one?(&block); end
+
+  sig { params(conditions: T.untyped).returns(T::Boolean) }
+  def exists?(conditions = nil); end
+
+  sig { override.params(block: T.proc.params(e: Elem).void).returns(T::Array[Elem]) }
+  def each(&block); end
+
+  sig { params(level: T.nilable(Integer)).returns(T::Array[Elem]) }
+  def flatten(level); end
+
+  sig { returns(T::Array[Elem]) }
+  def to_a; end
+
+  sig { type_parameters(:U).params(blk: T.proc.params(arg0: Elem).returns(T.type_parameter(:U))).returns(T::Array[T.type_parameter(:U)]) }
+  def map(&blk); end
+
+  sig { returns(T::Boolean) }
+  def empty?; end
+end
+
+class ActiveRecord::AssociationRelation < ActiveRecord::Relation
+  Elem = type_member {{fixed: T.untyped}}
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def new(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def build(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def create(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def create!(attributes = nil, &block); end
+end
+
+class ActiveRecord::Associations::CollectionProxy < ActiveRecord::Relation
+  Elem = type_member {{fixed: T.untyped}}
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def new(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def build(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def create(attributes = nil, &block); end
+
+  sig { params(attributes: T.untyped, block: T.nilable(T.proc.params(object: Elem).void)).returns(Elem) }
+  def create!(attributes = nil, &block); end
+
+  sig { params(args: T.untyped).returns(Elem) }
+  def find(*args); end
+
+  sig { params(limit: T.untyped).returns(T.nilable(Elem)) }
+  def last(limit = nil); end
+
+  sig { returns(T::Boolean) }
+  def empty?; end
+end

data/sorbet/rbi/shims/activerecord.rbi

@@ -0,0 +1,4 @@
+# typed: strict
+class ActiveRecord::Relation
+  Elem = type_member { {fixed: T.untyped} }
+end

data/sorbet/rbi/shims/model.rbi

@@ -0,0 +1,9 @@
+# typed: strict
+
+module ActsAsMessageable
+    module Model
+      module ClassMethods
+        mattr_accessor(:messages_class_name, :group_messages)
+      end
+    end
+end

data/sorbet/tapioca/config.yml

@@ -0,0 +1,10 @@
+gem:
+  prerequire: sorbet/tapioca/pre_require.rb
+  exclude:
+    - parlour
+    - sord
+    - rubocop
+    - rubocop-sorbet
+    - sorbet-rails
+dsl:
+

data/sorbet/tapioca/pre_require.rb

@@ -0,0 +1,5 @@
+# typed: true
+# frozen_string_literal: true
+
+# Needed for ancestry in order to generate types
+require 'active_support'

data/sorbet/tapioca/require.rb

@@ -0,0 +1,10 @@
+# typed: true
+# frozen_string_literal: true
+
+# Needed to generate types for ActiveRecord::Base
+require 'rails/generators/actions'
+require 'rails/generators/base'
+require 'rails/generators/migration'
+require 'rails/generators/active_record'
+require 'rails/all'
+require 'faraday/connection'