review.rbi

# This is an autogenerated file for dynamic methods in Review
# Please rerun bundle exec rake rails_rbi:models[Review] to regenerate.

# typed: strong
module Review::EnumInstanceMethods
  sig { returns(T::Boolean) }
  def no_final?; end

  sig { void }
  def no_final!; end

  sig { returns(T::Boolean) }
  def tenth_week?; end

  sig { void }
  def tenth_week!; end

  sig { returns(T::Boolean) }
  def finals_week?; end

  sig { void }
  def finals_week!; end

  sig { returns(T::Boolean) }
  def a_plus?; end

  sig { void }
  def a_plus!; end

  sig { returns(T::Boolean) }
  def a?; end

  sig { void }
  def a!; end

  sig { returns(T::Boolean) }
  def a_minus?; end

  sig { void }
  def a_minus!; end

  sig { returns(T::Boolean) }
  def b_plus?; end

  sig { void }
  def b_plus!; end

  sig { returns(T::Boolean) }
  def b?; end

  sig { void }
  def b!; end

  sig { returns(T::Boolean) }
  def b_minus?; end

  sig { void }
  def b_minus!; end

  sig { returns(T::Boolean) }
  def c_plus?; end

  sig { void }
  def c_plus!; end

  sig { returns(T::Boolean) }
  def c?; end

  sig { void }
  def c!; end

  sig { returns(T::Boolean) }
  def c_minus?; end

  sig { void }
  def c_minus!; end

  sig { returns(T::Boolean) }
  def d_plus?; end

  sig { void }
  def d_plus!; end

  sig { returns(T::Boolean) }
  def d?; end

  sig { void }
  def d!; end

  sig { returns(T::Boolean) }
  def d_minus?; end

  sig { void }
  def d_minus!; end

  sig { returns(T::Boolean) }
  def f?; end

  sig { void }
  def f!; end

  sig { returns(T::Boolean) }
  def pass?; end

  sig { void }
  def pass!; end

  sig { returns(T::Boolean) }
  def no_pass?; end

  sig { void }
  def no_pass!; end

  sig { returns(T::Boolean) }
  def pending?; end

  sig { void }
  def pending!; end

  sig { returns(T::Boolean) }
  def approved?; end

  sig { void }
  def approved!; end

  sig { returns(T::Boolean) }
  def rejected?; end

  sig { void }
  def rejected!; end

  sig { returns(T::Boolean) }
  def zero_to_five_hours?; end

  sig { void }
  def zero_to_five_hours!; end

  sig { returns(T::Boolean) }
  def five_to_ten_hours?; end

  sig { void }
  def five_to_ten_hours!; end

  sig { returns(T::Boolean) }
  def ten_to_fifteen_hours?; end

  sig { void }
  def ten_to_fifteen_hours!; end

  sig { returns(T::Boolean) }
  def fifteen_to_twenty_hours?; end

  sig { void }
  def fifteen_to_twenty_hours!; end

  sig { returns(T::Boolean) }
  def twenty_plus_hours?; end

  sig { void }
  def twenty_plus_hours!; end
end

module Review::ActiveRelation_WhereNot
  sig { params(opts: T.untyped, rest: T.untyped).returns(T.self_type) }
  def not(opts, *rest); end
end

module Review::GeneratedAttributeMethods
  sig { returns(T.nilable(Integer)) }
  def clarity; end

  sig { params(value: T.nilable(T.any(Numeric, ActiveSupport::Duration))).void }
  def clarity=(value); end

  sig { returns(T::Boolean) }
  def clarity?; end

  sig { returns(T.nilable(String)) }
  def comments; end

  sig { params(value: T.nilable(T.any(String, Symbol))).void }
  def comments=(value); end

  sig { returns(T::Boolean) }
  def comments?; end

  sig { returns(ActiveSupport::TimeWithZone) }
  def created_at; end

  sig { params(value: T.any(Date, Time, ActiveSupport::TimeWithZone)).void }
  def created_at=(value); end

  sig { returns(T::Boolean) }
  def created_at?; end

  sig { returns(T.nilable(String)) }
  def final; end

  sig { params(value: T.nilable(T.any(Integer, String, Symbol))).void }
  def final=(value); end

  sig { returns(T::Boolean) }
  def final?; end

  sig { returns(T.nilable(ActiveSupport::TimeWithZone)) }
  def first_approved_at; end

  sig { params(value: T.nilable(T.any(Date, Time, ActiveSupport::TimeWithZone))).void }
  def first_approved_at=(value); end

  sig { returns(T::Boolean) }
  def first_approved_at?; end

  sig { returns(T.nilable(String)) }
  def grade; end

  sig { params(value: T.nilable(T.any(Integer, String, Symbol))).void }
  def grade=(value); end

  sig { returns(T::Boolean) }
  def grade?; end

  sig { returns(T.nilable(T::Boolean)) }
  def has_group_project; end

  sig { params(value: T.nilable(T::Boolean)).void }
  def has_group_project=(value); end

  sig { returns(T::Boolean) }
  def has_group_project?; end

  sig { returns(T::Boolean) }
  def hidden; end

  sig { params(value: T::Boolean).void }
  def hidden=(value); end

  sig { returns(T::Boolean) }
  def hidden?; 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

  sig { returns(T.nilable(Integer)) }
  def midterm_count; end

  sig { params(value: T.nilable(T.any(Numeric, ActiveSupport::Duration))).void }
  def midterm_count=(value); end

  sig { returns(T::Boolean) }
  def midterm_count?; end

  sig { returns(T.nilable(T::Boolean)) }
  def offers_extra_credit; end

  sig { params(value: T.nilable(T::Boolean)).void }
  def offers_extra_credit=(value); end

  sig { returns(T::Boolean) }
  def offers_extra_credit?; end

  sig { returns(T.nilable(Integer)) }
  def organization; end

  sig { params(value: T.nilable(T.any(Numeric, ActiveSupport::Duration))).void }
  def organization=(value); end

  sig { returns(T::Boolean) }
  def organization?; end

  sig { returns(T.nilable(Integer)) }
  def overall; end

  sig { params(value: T.nilable(T.any(Numeric, ActiveSupport::Duration))).void }
  def overall=(value); end

  sig { returns(T::Boolean) }
  def overall?; end

  sig { returns(T.nilable(T::Boolean)) }
  def recommend_textbook; end

  sig { params(value: T.nilable(T::Boolean)).void }
  def recommend_textbook=(value); end

  sig { returns(T::Boolean) }
  def recommend_textbook?; end

  sig { returns(T.nilable(Integer)) }
  def relationship_id; end

  sig { params(value: T.nilable(T.any(Numeric, ActiveSupport::Duration))).void }
  def relationship_id=(value); end

  sig { returns(T::Boolean) }
  def relationship_id?; end

  sig { returns(T.nilable(T::Boolean)) }
  def requires_attendance; end

  sig { params(value: T.nilable(T::Boolean)).void }
  def requires_attendance=(value); end

  sig { returns(T::Boolean) }
  def requires_attendance?; end

  sig { returns(String) }
  def status; end

  sig { params(value: T.any(Integer, String, Symbol)).void }
  def status=(value); end

  sig { returns(T::Boolean) }
  def status?; end

  sig { returns(ActiveSupport::TimeWithZone) }
  def updated_at; end

  sig { params(value: T.any(Date, Time, ActiveSupport::TimeWithZone)).void }
  def updated_at=(value); end

  sig { returns(T::Boolean) }
  def updated_at?; end

  sig { returns(T.nilable(String)) }
  def weekly_time; end

  sig { params(value: T.nilable(T.any(Integer, String, Symbol))).void }
  def weekly_time=(value); end

  sig { returns(T::Boolean) }
  def weekly_time?; end
end

module Review::GeneratedAssociationMethods
  sig { returns(T.nilable(::Course)) }
  def course; end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Course).void)).returns(::Course) }
  def build_course(*args, &block); end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Course).void)).returns(::Course) }
  def create_course(*args, &block); end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Course).void)).returns(::Course) }
  def create_course!(*args, &block); end

  sig { params(value: T.nilable(::Course)).void }
  def course=(value); end

  sig { returns(T.nilable(::Course)) }
  def reload_course; end

  sig { returns(T.nilable(::Instructor)) }
  def instructor; end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Instructor).void)).returns(::Instructor) }
  def build_instructor(*args, &block); end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Instructor).void)).returns(::Instructor) }
  def create_instructor(*args, &block); end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Instructor).void)).returns(::Instructor) }
  def create_instructor!(*args, &block); end

  sig { params(value: T.nilable(::Instructor)).void }
  def instructor=(value); end

  sig { returns(T.nilable(::Instructor)) }
  def reload_instructor; end

  sig { returns(::Relationship) }
  def relationship; end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Relationship).void)).returns(::Relationship) }
  def build_relationship(*args, &block); end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Relationship).void)).returns(::Relationship) }
  def create_relationship(*args, &block); end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Relationship).void)).returns(::Relationship) }
  def create_relationship!(*args, &block); end

  sig { params(value: ::Relationship).void }
  def relationship=(value); end

  sig { returns(::Relationship) }
  def reload_relationship; end

  sig { returns(T.nilable(::Section)) }
  def section; end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Section).void)).returns(::Section) }
  def build_section(*args, &block); end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Section).void)).returns(::Section) }
  def create_section(*args, &block); end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Section).void)).returns(::Section) }
  def create_section!(*args, &block); end

  sig { params(value: T.nilable(::Section)).void }
  def section=(value); end

  sig { returns(T.nilable(::Section)) }
  def reload_section; end

  sig { returns(T.nilable(::Term)) }
  def term; end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Term).void)).returns(::Term) }
  def build_term(*args, &block); end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Term).void)).returns(::Term) }
  def create_term(*args, &block); end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::Term).void)).returns(::Term) }
  def create_term!(*args, &block); end

  sig { params(value: T.nilable(::Term)).void }
  def term=(value); end

  sig { returns(T.nilable(::Term)) }
  def reload_term; end

  sig { returns(T.nilable(::User)) }
  def user; end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::User).void)).returns(::User) }
  def build_user(*args, &block); end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::User).void)).returns(::User) }
  def create_user(*args, &block); end

  sig { params(args: T.untyped, block: T.nilable(T.proc.params(object: ::User).void)).returns(::User) }
  def create_user!(*args, &block); end

  sig { params(value: T.nilable(::User)).void }
  def user=(value); end

  sig { returns(T.nilable(::User)) }
  def reload_user; end
end

module Review::CustomFinderMethods
  sig { params(limit: Integer).returns(T::Array[Review]) }
  def first_n(limit); end

  sig { params(limit: Integer).returns(T::Array[Review]) }
  def last_n(limit); end

  sig { params(args: T::Array[T.any(Integer, String)]).returns(T::Array[Review]) }
  def find_n(*args); end

  sig { params(id: T.nilable(Integer)).returns(T.nilable(Review)) }
  def find_by_id(id); end

  sig { params(id: Integer).returns(Review) }
  def find_by_id!(id); end
end

class Review < ApplicationRecord
  include Review::EnumInstanceMethods
  include Review::GeneratedAttributeMethods
  include Review::GeneratedAssociationMethods
  extend Review::CustomFinderMethods
  extend Review::QueryMethodsReturningRelation
  RelationType = T.type_alias { T.any(Review::ActiveRecord_Relation, Review::ActiveRecord_Associations_CollectionProxy, Review::ActiveRecord_AssociationRelation) }

  sig { returns(T::Hash[T.any(String, Symbol), String]) }
  def self.finals; end

  sig { returns(T::Hash[T.any(String, Symbol), String]) }
  def self.grades; end

  sig { returns(T::Hash[T.any(String, Symbol), String]) }
  def self.statuses; end

  sig { returns(T::Hash[T.any(String, Symbol), String]) }
  def self.weekly_times; end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.a(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.a_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.a_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.approved(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.b(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.b_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.b_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.c(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.c_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.c_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.d(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.d_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.d_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.f(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.fifteen_to_twenty_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.finals_week(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.five_to_ten_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.has_comment(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.no_final(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.no_pass(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_a(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_a_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_a_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_approved(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_b(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_b_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_b_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_c(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_c_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_c_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_d(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_d_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_d_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_f(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_fifteen_to_twenty_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_finals_week(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_five_to_ten_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_no_final(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_no_pass(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_pass(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_pending(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_rejected(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_ten_to_fifteen_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_tenth_week(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_twenty_plus_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.not_zero_to_five_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.pass(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.pending(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.rejected(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.ten_to_fifteen_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.tenth_week(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.twenty_plus_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.viewable(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def self.zero_to_five_hours(*args); end

  sig { returns(T.nilable(Review::Final)) }
  def typed_final; end

  sig { params(value: T.nilable(Review::Final)).void }
  def typed_final=(value); end

  sig { returns(T.nilable(Review::Grade)) }
  def typed_grade; end

  sig { params(value: T.nilable(Review::Grade)).void }
  def typed_grade=(value); end

  sig { returns(Review::Status) }
  def typed_status; end

  sig { params(value: Review::Status).void }
  def typed_status=(value); end

  sig { returns(T.nilable(Review::WeeklyTime)) }
  def typed_weekly_time; end

  sig { params(value: T.nilable(Review::WeeklyTime)).void }
  def typed_weekly_time=(value); end

  class Final < T::Enum
    enums do
      NoFinal = new(%q{no_final})
      TenthWeek = new(%q{tenth_week})
      FinalsWeek = new(%q{finals_week})
    end

  end

  class Grade < T::Enum
    enums do
      APlus = new(%q{a_plus})
      A = new(%q{a})
      AMinus = new(%q{a_minus})
      BPlus = new(%q{b_plus})
      B = new(%q{b})
      BMinus = new(%q{b_minus})
      CPlus = new(%q{c_plus})
      C = new(%q{c})
      CMinus = new(%q{c_minus})
      DPlus = new(%q{d_plus})
      D = new(%q{d})
      DMinus = new(%q{d_minus})
      F = new(%q{f})
      Pass = new(%q{pass})
      NoPass = new(%q{no_pass})
    end

  end

  class Status < T::Enum
    enums do
      Pending = new(%q{pending})
      Approved = new(%q{approved})
      Rejected = new(%q{rejected})
    end

  end

  class WeeklyTime < T::Enum
    enums do
      ZeroToFive = new(%q{zero_to_five})
      FiveToTen = new(%q{five_to_ten})
      TenToFifteen = new(%q{ten_to_fifteen})
      FifteenToTwenty = new(%q{fifteen_to_twenty})
      TwentyPlus = new(%q{twenty_plus})
    end

  end

  sig { params(num: T.nilable(Integer)).returns(Review::ActiveRecord_Relation) }
  def self.page(num = nil); end

  sig { params(num: Integer, max_per_page: T.nilable(Integer)).returns(Review::ActiveRecord_Relation) }
  def self.per(num, max_per_page = nil); end

  sig { params(num: Integer).returns(Review::ActiveRecord_Relation) }
  def self.padding(num); end

  sig { returns(Integer) }
  def self.default_per_page; end
end

class Review::ActiveRecord_Relation < ActiveRecord::Relation
  include Review::ActiveRelation_WhereNot
  include Review::CustomFinderMethods
  include Review::QueryMethodsReturningRelation
  Elem = type_member {{fixed: Review}}

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def a(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def a_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def a_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def approved(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def b(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def b_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def b_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def c(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def c_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def c_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def d(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def d_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def d_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def f(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def fifteen_to_twenty_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def finals_week(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def five_to_ten_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def has_comment(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def no_final(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def no_pass(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_a(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_a_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_a_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_approved(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_b(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_b_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_b_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_c(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_c_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_c_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_d(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_d_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_d_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_f(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_fifteen_to_twenty_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_finals_week(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_five_to_ten_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_no_final(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_no_pass(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_pass(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_pending(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_rejected(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_ten_to_fifteen_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_tenth_week(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_twenty_plus_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def not_zero_to_five_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def pass(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def pending(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def rejected(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def ten_to_fifteen_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def tenth_week(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def twenty_plus_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def viewable(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def zero_to_five_hours(*args); end

  sig { params(num: T.nilable(Integer)).returns(Review::ActiveRecord_Relation) }
  def page(num = nil); end

  sig { params(num: Integer, max_per_page: T.nilable(Integer)).returns(Review::ActiveRecord_Relation) }
  def per(num, max_per_page = nil); end

  sig { params(num: Integer).returns(Review::ActiveRecord_Relation) }
  def padding(num); end

  sig { returns(T::Boolean) }
  def last_page?; end
end

class Review::ActiveRecord_AssociationRelation < ActiveRecord::AssociationRelation
  include Review::ActiveRelation_WhereNot
  include Review::CustomFinderMethods
  include Review::QueryMethodsReturningAssociationRelation
  Elem = type_member {{fixed: Review}}

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def a(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def a_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def a_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def approved(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def b(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def b_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def b_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def c(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def c_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def c_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def d(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def d_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def d_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def f(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def fifteen_to_twenty_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def finals_week(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def five_to_ten_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def has_comment(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def no_final(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def no_pass(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_a(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_a_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_a_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_approved(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_b(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_b_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_b_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_c(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_c_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_c_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_d(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_d_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_d_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_f(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_fifteen_to_twenty_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_finals_week(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_five_to_ten_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_no_final(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_no_pass(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_pass(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_pending(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_rejected(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_ten_to_fifteen_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_tenth_week(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_twenty_plus_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_zero_to_five_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def pass(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def pending(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def rejected(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def ten_to_fifteen_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def tenth_week(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def twenty_plus_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def viewable(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def zero_to_five_hours(*args); end

  sig { params(num: T.nilable(Integer)).returns(Review::ActiveRecord_AssociationRelation) }
  def page(num = nil); end

  sig { params(num: Integer, max_per_page: T.nilable(Integer)).returns(Review::ActiveRecord_AssociationRelation) }
  def per(num, max_per_page = nil); end

  sig { params(num: Integer).returns(Review::ActiveRecord_AssociationRelation) }
  def padding(num); end

  sig { returns(T::Boolean) }
  def last_page?; end
end

class Review::ActiveRecord_Associations_CollectionProxy < ActiveRecord::Associations::CollectionProxy
  include Review::CustomFinderMethods
  include Review::QueryMethodsReturningAssociationRelation
  Elem = type_member {{fixed: Review}}

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def a(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def a_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def a_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def approved(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def b(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def b_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def b_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def c(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def c_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def c_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def d(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def d_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def d_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def f(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def fifteen_to_twenty_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def finals_week(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def five_to_ten_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def has_comment(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def no_final(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def no_pass(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_a(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_a_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_a_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_approved(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_b(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_b_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_b_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_c(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_c_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_c_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_d(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_d_minus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_d_plus(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_f(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_fifteen_to_twenty_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_finals_week(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_five_to_ten_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_no_final(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_no_pass(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_pass(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_pending(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_rejected(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_ten_to_fifteen_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_tenth_week(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_twenty_plus_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def not_zero_to_five_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def pass(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def pending(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def rejected(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def ten_to_fifteen_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def tenth_week(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def twenty_plus_hours(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def viewable(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def zero_to_five_hours(*args); end

  sig { params(records: T.any(Review, T::Array[Review])).returns(T.self_type) }
  def <<(*records); end

  sig { params(records: T.any(Review, T::Array[Review])).returns(T.self_type) }
  def append(*records); end

  sig { params(records: T.any(Review, T::Array[Review])).returns(T.self_type) }
  def push(*records); end

  sig { params(records: T.any(Review, T::Array[Review])).returns(T.self_type) }
  def concat(*records); end

  sig { params(num: T.nilable(Integer)).returns(Review::ActiveRecord_AssociationRelation) }
  def page(num = nil); end

  sig { params(num: Integer, max_per_page: T.nilable(Integer)).returns(Review::ActiveRecord_AssociationRelation) }
  def per(num, max_per_page = nil); end

  sig { params(num: Integer).returns(Review::ActiveRecord_AssociationRelation) }
  def padding(num); end

  sig { returns(T::Boolean) }
  def last_page?; end
end

module Review::QueryMethodsReturningRelation
  sig { returns(Review::ActiveRecord_Relation) }
  def all; end

  sig { params(block: T.nilable(T.proc.void)).returns(Review::ActiveRecord_Relation) }
  def unscoped(&block); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def reselect(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def order(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def reorder(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def group(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def limit(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def offset(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def joins(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def left_joins(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def left_outer_joins(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def where(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def rewhere(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def preload(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def extract_associated(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def eager_load(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def includes(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def from(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def lock(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def readonly(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def or(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def having(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def create_with(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def distinct(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def references(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def none(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def unscope(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def optimizer_hints(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def merge(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def except(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_Relation) }
  def only(*args); end

  sig { params(block: T.proc.params(e: Review).returns(T::Boolean)).returns(T::Array[Review]) }
  def select(&block); end

  sig { params(args: T.any(String, Symbol, T::Array[T.any(String, Symbol)])).returns(Review::ActiveRecord_Relation) }
  def select_columns(*args); end

  sig { params(args: Symbol).returns(Review::ActiveRecord_Relation) }
  def where_missing(*args); end

  sig { params(column: Symbol, values: T::Array[T.untyped]).returns(Review::ActiveRecord_Relation) }
  def in_order_of(column, values); end

  sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(Review::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: Review::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 Review::QueryMethodsReturningAssociationRelation
  sig { returns(Review::ActiveRecord_AssociationRelation) }
  def all; end

  sig { params(block: T.nilable(T.proc.void)).returns(Review::ActiveRecord_Relation) }
  def unscoped(&block); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def reselect(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def order(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def reorder(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def group(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def limit(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def offset(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def joins(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def left_joins(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def left_outer_joins(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def where(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def rewhere(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def preload(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def extract_associated(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def eager_load(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def includes(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def from(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def lock(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def readonly(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def or(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def having(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def create_with(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def distinct(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def references(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def none(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def unscope(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def optimizer_hints(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def merge(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def except(*args); end

  sig { params(args: T.untyped).returns(Review::ActiveRecord_AssociationRelation) }
  def only(*args); end

  sig { params(block: T.proc.params(e: Review).returns(T::Boolean)).returns(T::Array[Review]) }
  def select(&block); end

  sig { params(args: T.any(String, Symbol, T::Array[T.any(String, Symbol)])).returns(Review::ActiveRecord_AssociationRelation) }
  def select_columns(*args); end

  sig { params(args: Symbol).returns(Review::ActiveRecord_AssociationRelation) }
  def where_missing(*args); end

  sig { params(column: Symbol, values: T::Array[T.untyped]).returns(Review::ActiveRecord_AssociationRelation) }
  def in_order_of(column, values); end

  sig { params(args: T.untyped, block: T.nilable(T.proc.void)).returns(Review::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: Review::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