sorbet-rails 0.5.0 → 0.5.1

data/spec/support/v6.0/sorbet/rbi/sorbet-typed/lib/activemodel/all/activemodel.rbi

@@ -0,0 +1,422 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/activemodel/all/activemodel.rbi
+#
+# typed: false
+
+module ActiveModel::Dirty
+  extend T::Sig
+  sig { params(attr: Symbol, from: T.untyped, to: T.untyped).returns(T::Boolean) }
+  def attribute_changed?(attr, from: nil, to: nil); end
+
+  sig { params(attr_name: Symbol).returns(T::Boolean) }
+  def attribute_changed_in_place?(attr_name); end
+
+  sig { params(attr_name: Symbol).returns(T::Boolean) }
+  def attribute_previously_changed?(attr_name); end
+
+  sig { returns(T::Boolean) }
+  def changed?; end
+end
+
+module ActiveModel::Validations
+  module ClassMethods
+    # https://github.com/rails/rails/blob/v5.2.3/activemodel/lib/active_model/validations.rb#L136-L154
+    sig do
+      params(
+        names: T.any(Symbol, String),
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        on: T.any(Symbol, String),
+        prepend: T::Boolean,
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      ).void
+    end
+    def validate(
+      *names,
+      if: nil,
+      on: nil,
+      prepend: false,
+      unless: nil
+    ); end
+
+    # https://github.com/rails/rails/blob/v5.2.3/activemodel/lib/active_model/validations/validates.rb#L75-L105
+    sig do
+      params(
+        names: T.any(Symbol, String), # a splat of at least one attribute name
+        absence: T.any(T::Boolean, T::Hash[T.untyped, T.untyped]),
+        acceptance: T.any(T::Boolean, T::Hash[T.untyped, T.untyped]),
+        allow_blank: T::Boolean,
+        allow_nil: T::Boolean,
+        confirmation: T.any(T::Boolean, T::Hash[T.untyped, T.untyped]),
+        # `exclusion` and `inclusion` are tricky to type without better support
+        # for overloading and shapes. Value can be anything that responds to
+        # `include?` (e.g. (1..3)), or a hash having an `in` or `within` key,
+        # like { in: [1, 2, 3], ... }
+        exclusion: T::Enumerable[T.untyped],
+        # `format` hash must additionally contain either :with or :without keys.
+        # Alternatively, it can be a Regexp.
+        format: T.any(T::Hash[T.untyped, T.untyped], Regexp),
+        if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+        # `exclusion` and `inclusion` are tricky to type without better support
+        # for overloading and shapes. Value can be anything that responds to
+        # `include?` (e.g. (1..3)), or a hash having an `in` or `within` key,
+        # like { in: [1, 2, 3], ... }
+        inclusion: T::Enumerable[T.untyped],
+        # if Hash, must contain :in, :within, :maximum, :minimum, or :is keys
+        length: T.any(T::Range, T::Hash[T.untyped, T.untyped]),
+        numericality: T.any(T::Boolean, T::Hash[T.untyped, T.untyped]),
+        on: T.any(Symbol, String, T::Array[T.any(Symbol, String)]),
+        presence: T::Boolean,
+        size: T.any(T::Boolean, T::Hash[T.untyped, T.untyped]),
+        strict: T::Boolean,
+        uniqueness: T.any(T::Boolean, T::Hash[T.untyped, T.untyped]),
+        unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      ).void
+    end
+    def validates(
+      *names,
+      absence: false,
+      acceptance: {},
+      allow_blank: false,
+      allow_nil: false,
+      confirmation: false,
+      exclusion: [],
+      format: {},
+      if: nil,
+      inclusion: [],
+      length: {},
+      numericality: false,
+      on: :_,
+      presence: false,
+      size: false,
+      strict: false,
+      uniqueness: false,
+      unless: :_
+    )
+    end
+  end
+end
+
+class ActiveModel::Type::Boolean
+  sig { params(arg0: T.untyped).returns(T.nilable(T::Boolean))}
+  def cast(arg0); end
+end
+
+module ActiveModel::Validations::HelperMethods
+  sig do
+    params(
+      attr_names: T.any(String, Symbol),
+      message: String,
+      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      on: T.any(Symbol, String),
+      allow_nil: T::Boolean,
+      allow_blank: T::Boolean,
+      strict: T::Boolean
+    ).void
+  end
+  def validates_absence_of(
+    *attr_names,
+    message: 'must be blank', 
+    if: nil, 
+    unless: :_, 
+    on: :_, 
+    allow_nil: false, 
+    allow_blank: false, 
+    strict: false
+  ); end
+
+  sig do
+    params(
+      attr_names: T.any(String, Symbol),
+      message: String,
+      accept: T.untyped,
+      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      on: T.any(Symbol, String),
+      allow_nil: T::Boolean,
+      allow_blank: T::Boolean,
+      strict: T::Boolean
+    ).void
+  end
+  def validates_acceptance_of(
+    *attr_names,
+    message: 'must be accepted', 
+    accept: ['1', true], 
+    if: nil, 
+    unless: :_, 
+    on: :_, 
+    allow_nil: false, 
+    allow_blank: false,
+    strict: false
+  ); end
+
+  sig do
+    params(
+      attr_names: T.any(String, Symbol),
+      message: String,
+      case_sensitive: T::Boolean,
+      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      on: T.any(Symbol, String),
+      allow_nil: T::Boolean,
+      allow_blank: T::Boolean,
+      strict: T::Boolean
+    ).void
+  end
+  def validates_confirmation_of(
+    *attr_names,
+    message: "doesn't match %{translated_attribute_name}",
+    case_sensitive: true,
+    if: nil,
+    unless: :_,
+    on: :_,
+    allow_nil: false,
+    allow_blank: false,
+    strict: false
+  ); end
+
+  # A type alias for the in/within parameters on the
+  # validates_(inclusion/exclusion)_of methods.
+  InWithinType = T.type_alias(
+    T.nilable(
+      T.any(
+        Symbol,
+        String,
+        T::Array[T.any(String, Symbol)],
+        T::Range[Integer],
+        T.proc.params(arg0: T.untyped).returns(T::Boolean)
+      )
+    )
+  )
+  sig do
+    params(
+      attr_names: T.any(String, Symbol),
+      message: String,
+      in: InWithinType,
+      within: InWithinType,
+      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      on: T.any(Symbol, String),
+      allow_nil: T::Boolean,
+      allow_blank: T::Boolean,
+      strict: T::Boolean
+    ).void
+  end
+  def validates_exclusion_of(
+    *attr_names,
+    message: 'is reserved',
+    in: nil,
+    within: nil,
+    if: nil,
+    unless: :_,
+    on: :_,
+    allow_nil: false,
+    allow_blank: false,
+    strict: false
+  ); end
+
+  sig do
+    params(
+      attr_names: T.any(String, Symbol),
+      message: String,
+      with: T.untyped,
+      without: T.untyped,
+      multiline: T.untyped,
+      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      on: T.any(Symbol, String),
+      allow_nil: T::Boolean,
+      allow_blank: T::Boolean,
+      strict: T::Boolean
+    ).void
+  end
+  def validates_format_of(
+    *attr_names,
+    message: 'is invalid',
+    with: nil,
+    without: nil,
+    multiline: nil,
+    if: nil,
+    unless: :_,
+    on: :_,
+    allow_nil: false,
+    allow_blank: false,
+    strict: false
+  ); end
+
+  sig do
+    params(
+      attr_names: T.any(String, Symbol),
+      message: String,
+      in: InWithinType,
+      within: InWithinType,
+      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      on: T.any(Symbol, String),
+      allow_nil: T::Boolean,
+      allow_blank: T::Boolean,
+      strict: T::Boolean
+    ).void
+  end
+  def validates_inclusion_of(
+    *attr_names,
+    message: 'is not included in the list',
+    in: nil,
+    within: nil,
+    if: nil,
+    unless: :_,
+    on: :_,
+    allow_nil: false,
+    allow_blank: false,
+    strict: false
+  ); end
+
+  sig do
+    params(
+      attr_names: T.any(String, Symbol),
+      message: T.nilable(String),
+      minimum: T.nilable(Integer),
+      maximum: T.nilable(Integer),
+      is: T.nilable(Integer),
+      within: T.nilable(T::Range[Integer]),
+      in: T.nilable(T::Range[Integer]),
+      too_long: String,
+      too_short: String,
+      wrong_length: String,
+      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      on: T.any(Symbol, String),
+      allow_nil: T::Boolean,
+      allow_blank: T::Boolean,
+      strict: T::Boolean
+    ).void
+  end
+  def validates_length_of(
+    *attr_names,
+    message: nil,
+    minimum: nil,
+    maximum: nil,
+    is: nil,
+    within: nil,
+    in: nil,
+    too_long: 'is too long (maximum is %{count} characters)',
+    too_short: 'is too short (minimum is %{count} characters)',
+    wrong_length: 'is the wrong length (should be %{count} characters)',
+    if: nil,
+    unless: :_,
+    on: :_,
+    allow_nil: false,
+    allow_blank: false,
+    strict: false
+  ); end
+  
+  # validates_size_of is an alias of validates_length_of
+  sig do
+    params(
+      attr_names: T.any(String, Symbol),
+      message: T.nilable(String),
+      minimum: T.nilable(Integer),
+      maximum: T.nilable(Integer),
+      is: T.nilable(Integer),
+      within: T.nilable(T::Range[Integer]),
+      in: T.nilable(T::Range[Integer]),
+      too_long: String,
+      too_short: String,
+      wrong_length: String,
+      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      on: T.any(Symbol, String),
+      allow_nil: T::Boolean,
+      allow_blank: T::Boolean,
+      strict: T::Boolean
+    ).void
+  end
+  def validates_size_of(
+    *attr_names,
+    message: nil,
+    minimum: nil,
+    maximum: nil,
+    is: nil,
+    within: nil,
+    in: nil,
+    too_long: 'is too long (maximum is %{count} characters)',
+    too_short: 'is too short (minimum is %{count} characters)',
+    wrong_length: 'is the wrong length (should be %{count} characters)',
+    if: nil,
+    unless: :_,
+    on: :_,
+    allow_nil: false,
+    allow_blank: false,
+    strict: false
+  ); end
+
+  # Create a type alias so we don't have to repeat this long type signature 6 times.
+  NumberComparatorType = T.type_alias(T.nilable(T.any(Integer, Float, T.proc.params(arg0: T.untyped).returns(T::Boolean), Symbol)))
+  sig do
+    params(
+      attr_names: T.any(String, Symbol),
+      message: String,
+      only_integer: T::Boolean,
+      greater_than: NumberComparatorType,
+      greater_than_or_equal_to: NumberComparatorType,
+      equal_to: NumberComparatorType,
+      less_than: NumberComparatorType,
+      less_than_or_equal_to: NumberComparatorType,
+      other_than: NumberComparatorType,
+      odd: T::Boolean,
+      even: T::Boolean,
+      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      on: T.any(Symbol, String),
+      allow_nil: T::Boolean,
+      allow_blank: T::Boolean,
+      strict: T::Boolean
+    ).void
+  end
+  def validates_numericality_of(
+    *attr_names,
+    message: 'is not a number',
+    only_integer: false,
+    greater_than: nil,
+    greater_than_or_equal_to: nil,
+    equal_to: nil,
+    less_than: nil,
+    less_than_or_equal_to: nil,
+    other_than: nil,
+    odd: false,
+    even: false,
+    if: nil,
+    unless: :_,
+    on: :_,
+    allow_nil: false,
+    allow_blank: false,
+    strict: false
+  ); end
+
+  sig do
+    params(
+      attr_names: T.any(String, Symbol),
+      message: String,
+      if: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      unless: T.any(Symbol, String, T.proc.params(arg0: T.untyped).returns(T::Boolean)),
+      on: T.any(Symbol, String),
+      allow_nil: T::Boolean,
+      allow_blank: T::Boolean,
+      strict: T::Boolean
+    ).void
+  end
+  def validates_presence_of(
+    *attr_names,
+    message: "can't be blank",
+    if: nil,
+    unless: :_,
+    on: :_,
+    allow_nil: false,
+    allow_blank: false,
+    strict: false
+  ); end
+end

data/spec/support/v6.0/sorbet/rbi/sorbet-typed/lib/activerecord/>=5.2/activerecord.rbi

@@ -0,0 +1,17 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/activerecord/>=5.2/activerecord.rbi
+#
+# typed: strong
+
+class ActiveRecord::Base
+  extend ActiveRecord::Delegation::DelegateCache
+  extend ActiveRecord::CollectionCacheKey
+  include ActiveRecord::DefineCallbacks
+  include ActiveRecord::TouchLater
+  include ActiveRecord::SecureToken
+  include ActiveRecord::Suppressor
+end

data/spec/support/v6.0/sorbet/rbi/sorbet-typed/lib/activerecord/all/activerecord.rbi

@@ -5,47 +5,1259 @@
 #
 #   https://github.com/sorbet/sorbet-typed/edit/master/lib/activerecord/all/activerecord.rbi
 #
-# typed: strong
+# typed: false
+
+VariadicUntypedFunction = T.type_alias(
+  T.any(
+    T.proc.returns(T.untyped),
+    T.proc.params(arg0: T.untyped).returns(T.untyped),
+    T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T.untyped),
+    T.proc.params(arg0: T.untyped, arg1: T.untyped, arg2: T.untyped).returns(T.untyped),
+    T.proc.params(arg0: T.untyped, arg1: T.untyped, arg2: T.untyped, arg3: T.untyped).returns(T.untyped),
+    T.proc.params(arg0: T.untyped, arg1: T.untyped, arg2: T.untyped, arg3: T.untyped, arg4: T.untyped).returns(T.untyped),
+    T.proc.params(arg0: T.untyped, arg1: T.untyped, arg2: T.untyped, arg3: T.untyped, arg4: T.untyped, arg5: T.untyped).returns(T.untyped),
+    T.proc.params(arg0: T.untyped, arg1: T.untyped, arg2: T.untyped, arg3: T.untyped, arg4: T.untyped, arg5: T.untyped, arg6: T.untyped).returns(T.untyped),
+    T.proc.params(arg0: T.untyped, arg1: T.untyped, arg2: T.untyped, arg3: T.untyped, arg4: T.untyped, arg5: T.untyped, arg6: T.untyped, arg7: T.untyped).returns(T.untyped),
+    T.proc.params(arg0: T.untyped, arg1: T.untyped, arg2: T.untyped, arg3: T.untyped, arg4: T.untyped, arg5: T.untyped, arg6: T.untyped, arg7: T.untyped, arg8: T.untyped).returns(T.untyped),
+    T.proc.params(arg0: T.untyped, arg1: T.untyped, arg2: T.untyped, arg3: T.untyped, arg4: T.untyped, arg5: T.untyped, arg6: T.untyped, arg7: T.untyped, arg8: T.untyped, arg9: T.untyped).returns(T.untyped)
+    # Currently Sorbet is limited to procs with 9 args: https://github.com/sorbet/sorbet/blob/df6085e6ae9846f033064513ea14f069c68b0bf9/core/SymbolRef.h#L387
+  )
+)
+
+module ActiveRecord::Associations::ClassMethods
+  sig do
+    params(
+      name: Symbol,
+      scope: T.nilable(T.proc.void),
+      after_add: T.nilable(T.any(Symbol, String, T.proc.void)),
+      after_remove: T.nilable(T.any(Symbol, String, T.proc.void)),
+      anonymous_class: T.nilable(T.any(Symbol, String)),
+      as: T.nilable(T.any(Symbol, String)),
+      autosave: T.nilable(T::Boolean),
+      before_add: T.nilable(T.any(Symbol, String, T.proc.void)),
+      before_remove: T.nilable(T.any(Symbol, String, T.proc.void)),
+      class_name: T.nilable(T.any(Symbol, String)),
+      counter_cache: T.nilable(T.any(Symbol, String)),
+      dependent: T.nilable(T.any(Symbol, String)),
+      extend: T.nilable(T.any(Module, T::Array[Module])),
+      foreign_key: T.nilable(T.any(Symbol, String)),
+      foreign_type: T.nilable(T.any(Symbol, String)),
+      index_errors: T.nilable(T::Boolean),
+      inverse_of: T.nilable(T.any(Symbol, String)),
+      join_table: T.nilable(T.any(Symbol, String)),
+      primary_key: T.nilable(T.any(Symbol, String)),
+      source: T.nilable(T.any(Symbol, String)),
+      source_type: T.nilable(T.any(Symbol, String)),
+      table_name: T.nilable(T.any(Symbol, String)),
+      through: T.nilable(T.any(Symbol, String)),
+      validate: T.nilable(T::Boolean),
+      blk: T.nilable(T.proc.void)
+    ).void
+  end
+  def has_many(
+    name,
+    scope = nil,
+    after_add: nil,
+    after_remove: nil,
+    anonymous_class: nil,
+    as: nil,
+    autosave: nil,
+    before_add: nil,
+    before_remove: nil,
+    class_name: nil,
+    counter_cache: nil,
+    dependent: nil,
+    extend: nil,
+    foreign_key: nil,
+    foreign_type: nil,
+    index_errors: nil,
+    inverse_of: nil,
+    join_table: nil,
+    primary_key: nil,
+    source: nil,
+    source_type: nil,
+    table_name: nil,
+    through: nil,
+    validate: nil,
+    &blk
+  ); end
+
+  sig do
+    params(
+      name: Symbol,
+      scope: T.nilable(T.proc.void),
+      anonymous_class: T.nilable(T.any(Symbol, String)),
+      as: T.nilable(T.any(Symbol, String)),
+      autosave: T.nilable(T::Boolean),
+      class_name: T.nilable(T.any(Symbol, String)),
+      dependent: T.nilable(T.any(Symbol, String)),
+      foreign_key: T.nilable(T.any(Symbol, String)),
+      foreign_type: T.nilable(T.any(Symbol, String)),
+      inverse_of: T.nilable(T.any(Symbol, String)),
+      primary_key: T.nilable(T.any(Symbol, String)),
+      required: T.nilable(T::Boolean),
+      source: T.nilable(T.any(Symbol, String)),
+      source_type: T.nilable(T.any(Symbol, String)),
+      through: T.nilable(T.any(Symbol, String)),
+      validate: T.nilable(T::Boolean),
+      blk: T.nilable(T.proc.void)
+    ).void
+  end
+  def has_one(
+    name,
+    scope = nil,
+    anonymous_class: nil,
+    as: nil,
+    autosave: nil,
+    class_name: nil,
+    dependent: nil,
+    foreign_key: nil,
+    foreign_type: nil,
+    inverse_of: nil,
+    primary_key: nil,
+    required: nil,
+    source: nil,
+    source_type: nil,
+    through: nil,
+    validate: nil,
+    &blk
+  ); end
 
-class ActiveRecord::Base
   sig do
     params(
-      model: Symbol,
+      name: T.nilable(T.any(Symbol, String)),
+      scope: T.nilable(T.proc.void),
       autosave: T.nilable(T::Boolean),
-      class_name: T.nilable(String),
-      counter_cache: T.nilable(T.any(T::Boolean, Symbol)),
-      dependent: T.nilable(Symbol),
-      foreign_key: T.nilable(Symbol),
-      primary_key: T.nilable(Symbol),
-      inverse_of: T.nilable(Symbol),
+      class_name: T.nilable(T.any(Symbol, String)),
+      counter_cache: T.nilable(T::Boolean),
+      dependent: T.nilable(T.any(Symbol, String)),
+      foreign_key: T.nilable(T.any(Symbol, String)),
+      foreign_type: T.nilable(T.any(Symbol, String)),
+      inverse_of: T.nilable(T.any(Symbol, String)),
+      optional: T.nilable(T::Boolean),
       polymorphic: T.nilable(T::Boolean),
+      primary_key: T.nilable(T.any(Symbol, String)),
+      required: T.nilable(T::Boolean),
       touch: T.nilable(T.any(T::Boolean, Symbol)),
       validate: T.nilable(T::Boolean),
-      optional: T.nilable(T::Boolean)
+      default: T.nilable(T.proc.returns(T.untyped))
     ).void
   end
-  def self.belongs_to(
-    model,
+  def belongs_to(
+    name,
+    scope = nil,
     autosave: nil,
     class_name: nil,
     counter_cache: nil,
     dependent: nil,
     foreign_key: nil,
-    primary_key: nil,
+    foreign_type: nil,
     inverse_of: nil,
+    optional: nil,
     polymorphic: nil,
+    primary_key: nil,
+    required: nil,
     touch: nil,
     validate: nil,
-    optional: nil
+    default: nil
+  ); end
+
+  sig do
+    params(
+      name: T.nilable(T.any(Symbol, String)),
+      scope: T.nilable(T.proc.void),
+      after_add: T.nilable(T.any(Symbol, String, T.proc.void)),
+      after_remove: T.nilable(T.any(Symbol, String, T.proc.void)),
+      association_foreign_key: T.nilable(T.any(Symbol, String)),
+      autosave: T.nilable(T::Boolean),
+      before_add: T.nilable(T.any(Symbol, String, T.proc.void)),
+      before_remove: T.nilable(T.any(Symbol, String, T.proc.void)),
+      class_name: T.nilable(T.any(Symbol, String)),
+      extend: T.nilable(T.any(Module, T::Array[Module])),
+      foreign_key: T.nilable(T.any(Symbol, String)),
+      join_table: T.nilable(T.any(Symbol, String)),
+      validate: T.nilable(T::Boolean),
+      blk: T.nilable(T.proc.void)
+    ).void
+  end
+  def has_and_belongs_to_many(
+    name,
+    scope = nil,
+    after_add: nil,
+    after_remove: nil,
+    association_foreign_key: nil,
+    autosave: nil,
+    before_add: nil,
+    before_remove: nil,
+    class_name: nil,
+    extend: nil,
+    foreign_key: nil,
+    join_table: nil,
+    validate: nil,
+    &blk
+  ); end
+end
+
+module ActiveRecord::AttributeMethods
+  include ActiveModel::AttributeMethods
+end
+
+module ActiveRecord::AttributeMethods::Serialization::ClassMethods
+  sig { params(attr_name: Symbol, class_name_or_coder: T.untyped).void }
+  def serialize(attr_name, class_name_or_coder = Object); end
+end
+
+module ActiveRecord::NestedAttributes::ClassMethods
+  sig do
+    params(
+      attr_names: T.any(T.any(Symbol, String), T::Array[T.any(Symbol, String)]),
+      allow_destroy: T.nilable(T::Boolean),
+      reject_if: T.any(Symbol, T.proc.returns(T::Boolean)),
+      limit: T.any(Integer, Symbol, T.proc.returns(Integer)),
+      update_only: T.nilable(T::Boolean),
+    ).void
+  end
+  def accepts_nested_attributes_for(
+    attr_names,
+    allow_destroy: nil,
+    reject_if: nil,
+    limit: nil,
+    update_only: nil
+  ); end
+end
+
+module ActiveRecord::Scoping::Named::ClassMethods
+  sig do
+    params(
+      name: T.nilable(T.any(Symbol, String)),
+      body: VariadicUntypedFunction,
+      blk: T.nilable(VariadicUntypedFunction)
+    ).void
+  end
+  def scope(
+    name,
+    body,
+    &blk
+  ); end
+end
+
+module ActiveRecord::Scoping::Default::ClassMethods
+end
+
+module ActiveRecord::Inheritance
+  mixes_in_class_methods(ActiveRecord::Inheritance::ClassMethods)
+end
+
+class ActiveRecord::Base
+  extend ActiveModel::Naming
+
+  extend ActiveSupport::Benchmarkable
+  extend ActiveSupport::DescendantsTracker
+
+  extend ActiveRecord::ConnectionHandling
+  extend ActiveRecord::QueryCache::ClassMethods
+  extend ActiveRecord::Querying
+  extend ActiveRecord::Translation
+  extend ActiveRecord::DynamicMatchers
+  extend ActiveRecord::Explain
+  extend ActiveRecord::Enum
+
+  include ActiveRecord::Core
+  include ActiveRecord::Persistence
+  include ActiveRecord::ReadonlyAttributes
+  include ActiveRecord::ModelSchema
+  include ActiveRecord::Inheritance
+  include ActiveRecord::Scoping
+  include ActiveRecord::Scoping::Default # via ActiveRecord::Scoping#included hook
+  extend ActiveRecord::Scoping::Default::ClassMethods # via ActiveRecord::Scoping::Default Concern inclusion
+  include ActiveRecord::Scoping::Named # via ActiveRecord::Scoping#included hook
+  extend ActiveRecord::Scoping::Named::ClassMethods # via ActiveRecord::Scoping::Named Concern inclusion
+  include ActiveRecord::Sanitization
+  include ActiveRecord::AttributeAssignment
+  include ActiveModel::Conversion
+  include ActiveRecord::Integration
+  include ActiveRecord::Validations
+  include ActiveRecord::CounterCache
+  include ActiveRecord::Attributes
+  include ActiveRecord::AttributeDecorators
+  include ActiveRecord::Locking::Optimistic
+  include ActiveRecord::Locking::Pessimistic
+  include ActiveRecord::AttributeMethods
+  include ActiveRecord::AttributeMethods::Read # via ActiveRecord::AttributeMethods#included hook
+  include ActiveRecord::AttributeMethods::Write # via ActiveRecord::AttributeMethods#included hook
+  include ActiveRecord::AttributeMethods::BeforeTypeCast # via ActiveRecord::AttributeMethods#included hook
+  include ActiveRecord::AttributeMethods::Query # via ActiveRecord::AttributeMethods#included hook
+  include ActiveRecord::AttributeMethods::PrimaryKey # via ActiveRecord::AttributeMethods#included hook
+  include ActiveRecord::AttributeMethods::TimeZoneConversion # via ActiveRecord::AttributeMethods#included hook
+  include ActiveRecord::AttributeMethods::Dirty # via ActiveRecord::AttributeMethods#included hook
+  include ActiveRecord::AttributeMethods::Serialization # via ActiveRecord::AttributeMethods#included hook
+  extend ActiveRecord::AttributeMethods::Serialization::ClassMethods # via ActiveRecord::AttributeMethods::Serialization Concern inclusion
+  include ActiveRecord::Callbacks
+  include ActiveRecord::Timestamp
+  include ActiveRecord::Associations
+  include ActiveModel::SecurePassword
+  include ActiveRecord::AutosaveAssociation
+  include ActiveRecord::NestedAttributes
+  extend ActiveRecord::NestedAttributes::ClassMethods # via ActiveRecord::NestedAttributes Concern inclusion
+  include ActiveRecord::Aggregations
+  include ActiveRecord::Transactions
+  include ActiveRecord::NoTouching
+  include ActiveRecord::Reflection
+  include ActiveRecord::Serialization
+  include ActiveRecord::Store
+
+  sig do
+    params(
+      arg: Symbol,
+      if: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      on: T.nilable(Symbol),
+      unless: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.after_commit(
+    arg,
+    if: nil,
+    on: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.after_create(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.after_destroy(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.after_rollback(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.after_save(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.after_update(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.after_validation(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.around_create(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.around_destroy(
+    arg = nil,
+    if: nil,
+    unless: nil
   ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.around_save(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.around_update(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.before_create(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.before_destroy(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.before_save(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean))))
+    ).void
+  end
+  def self.before_update(
+    arg = nil,
+    if: nil,
+    unless: nil
+  ); end
+
+  sig do
+    params(
+      arg: T.nilable(Symbol),
+      if: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      unless: T.nilable(T.any(Symbol, T.proc.params(arg0: T.untyped).returns(T.nilable(T::Boolean)))),
+      on: T.nilable(Symbol)
+    ).void
+  end
+  def self.before_validation(
+    arg = nil,
+    if: nil,
+    unless: nil,
+    on: nil
+  ); end
+end
+
+module ActiveRecord::Inheritance::ClassMethods
+  sig { params(value: T::Boolean).void }
+  def abstract_class=(value); end
+
+  sig { returns(T::Boolean) }
+  def abstract_class; end
+end
+
+module ActiveRecord::Persistence
+  mixes_in_class_methods(ActiveRecord::Persistence::ClassMethods)
+
+  sig { params(klass: Class).returns(T.untyped) }
+  def becomes!(klass); end
+
+  sig { params(klass: Class).returns(T.untyped) }
+  def becomes(klass); end
+
+  sig do
+    params(
+      attribute: T.any(Symbol, String),
+      by: T.nilable(Integer),
+      touch: T.nilable(T::Boolean)
+    ).returns(T.self_type)
+  end
+  def decrement!(attribute, by = 1, touch: nil); end
+
+  sig do
+    params(
+      attribute: T.any(Symbol, String),
+      by: T.nilable(Integer)
+    ).returns(T.self_type)
+  end
+  def decrement(attribute, by = 1); end
+
+  sig { returns(T::Boolean) }
+  def destroyed?(); end
+
+  sig do
+    params(
+      attribute: T.any(Symbol, String),
+      by: T.nilable(Integer),
+      touch: T.nilable(T::Boolean)
+    ).returns(T.self_type)
+  end
+  def increment!(attribute, by = 1, touch: nil); end
+
+  sig do
+    params(
+      attribute: T.any(Symbol, String),
+      by: T.nilable(Integer)
+    ).returns(T.self_type)
+  end
+  def increment(attribute, by = 1); end
+
+  sig { returns(T::Boolean) }
+  def new_record?(); end
+
+  sig { returns(T::Boolean) }
+  def persisted?(); end
+
+  sig do
+    params(
+      options: T.nilable({ lock: T.nilable(T::Boolean) })
+    ).returns(T.self_type)
+  end
+  def reload(options = nil); end
+
+  sig do
+    params(
+      args: T.untyped,
+      blk: T.proc.void,
+    ).returns(TrueClass)
+  end
+  def save!(*args, &blk); end
+
+  sig do
+    params(
+      args: T.untyped,
+      blk: T.proc.void,
+    ).returns(T::Boolean)
+  end
+  def save(*args, &blk); end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(TrueClass) }
+  def toggle!(attribute); end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T.self_type) }
+  def toggle(attribute); end
+
+  sig do
+    params(
+      names: T.any(
+        Symbol,
+        String,
+        T::Array[T.any(Symbol, String)]
+      ),
+      time: T.nilable(Time)
+    ).returns(T::Boolean)
+  end
+  def touch(*names, time: nil); end
+
+  sig do
+    params(
+      name: T.any(Symbol, String),
+      value: T.untyped,
+    ).returns(T::Boolean)
+  end
+  def update_attribute(name, value); end
+
+  sig do
+    params(
+      name: T.any(Symbol, String),
+      value: T.untyped,
+    ).returns(T::Boolean)
+  end
+  def update_column(name, value); end
+
+  sig do
+    params(
+      attributes: T::Hash[T.any(Symbol, String), T.untyped]
+    ).returns(T::Boolean)
+  end
+  def update_columns(attributes); end
+
+  sig do
+    params(
+      attributes: T::Hash[T.any(Symbol, String), T.untyped]
+    ).returns(TrueClass)
+  end
+  def update!(attributes); end
+
+  # update_attributes! is an alias of update!
+  sig do
+    params(
+      attributes: T::Hash[T.any(Symbol, String), T.untyped]
+    ).returns(TrueClass)
+  end
+  def update_attributes!(attributes); end
+
+  sig do
+    params(
+      attributes: T::Hash[T.any(Symbol, String), T.untyped]
+    ).returns(T::Boolean)
+  end
+  def update(attributes); end
+
+  # update_attributes is an alias of update
+  sig do
+    params(
+      attributes: T::Hash[T.any(Symbol, String), T.untyped]
+    ).returns(T::Boolean)
+  end
+  def update_attributes(attributes); end
 end
 
-class ActiveRecord::Schema
+module ActiveRecord::Persistence::ClassMethods
+  sig do
+    params(
+      attributes: T.nilable(T.any(
+        T::Hash[T.any(Symbol, String), T.untyped],
+        T::Array[T::Hash[T.any(Symbol, String), T.untyped]]
+      )),
+      blk: T.nilable(T.proc.params(arg0: T.untyped).returns(T.untyped))
+    ).returns(T.untyped)
+  end
+  def create!(attributes = nil, &blk); end
+
+  sig do
+    params(
+      attributes: T.nilable(T.any(
+        T::Hash[T.any(Symbol, String), T.untyped],
+        T::Array[T::Hash[T.any(Symbol, String), T.untyped]]
+      )),
+      blk: T.nilable(T.proc.params(arg0: T.untyped).returns(T.untyped))
+    ).returns(T.untyped)
+  end
+  def create(attributes = nil, &blk); end
+
+  sig do
+    params(
+      id_or_array: T.any(T.untyped, T::Array[T.untyped])
+    ).returns(T.untyped)
+  end
+  def delete(id_or_array); end
+
+  sig do
+    params(
+      id_or_array: T.any(T.untyped, T::Array[T.untyped])
+    ).returns(T.untyped)
+  end
+  def destroy!(id_or_array); end
+
+  sig do
+    params(
+      id_or_array: T.any(T.untyped, T::Array[T.untyped])
+    ).returns(T.untyped)
+  end
+  def destroy(id_or_array); end
+
+  sig do
+    params(
+      attributes: T::Array[T::Hash[T.any(Symbol, String), T.untyped]],
+      returning: T.nilable(T.any(FalseClass, T::Array[T.any(Symbol, String)]))
+    ).returns(ActiveRecord::Result)
+  end
+  def insert_all!(attributes, returning: nil); end
+
+  sig do
+    params(
+      attributes: T::Array[T::Hash[T.any(Symbol, String), T.untyped]],
+      returning: T.nilable(T.any(FalseClass, T::Array[T.any(Symbol, String)])),
+      unique_by: T.nilable(T.untyped)
+    ).returns(ActiveRecord::Result)
+  end
+  def insert_all(attributes, returning: nil, unique_by: nil); end
+
+  sig do
+    params(
+      attributes: T::Hash[T.any(Symbol, String), T.untyped],
+      returning: T.nilable(T.any(FalseClass, T::Array[T.any(Symbol, String)])),
+      unique_by: T.nilable(T.untyped)
+    ).returns(ActiveRecord::Result)
+  end
+  def insert!(attributes, returning: nil, unique_by: nil); end
+
+  sig do
+    params(
+      attributes: T::Hash[T.any(Symbol, String), T.untyped],
+      returning: T.nilable(T.any(FalseClass, T::Array[T.any(Symbol, String)])),
+      unique_by: T.nilable(T.untyped)
+    ).returns(ActiveRecord::Result)
+  end
+  def insert(attributes, returning: nil, unique_by: nil); end
+
+  sig { params(attributes: T.untyped, column_types: T::Hash[T.untyped, T.untyped], blk: T.proc.void).returns(T.untyped) }
+  def instantiate(attributes, column_types = {}, &blk); end
+
+  # The 'attributes' parameter can take either a hash or an array of hashes.
+  sig do
+    params(
+      id: T.any(T.untyped, T::Array[T.untyped], Symbol),
+      attributes: T.any(
+        T::Hash[T.any(Symbol, String), T.untyped],
+        T::Array[T::Hash[T.any(Symbol, String), T.untyped]]
+      )
+    ).returns(T.any(T::Array[T.untyped], T.untyped))
+  end
+  def update(id = :all, attributes); end
+
+  sig do
+    params(
+      attributes: T::Array[T::Hash[T.any(Symbol, String), T.untyped]],
+      returning: T.nilable(T.any(FalseClass, T::Array[T.any(Symbol, String)])),
+      unique_by: T.nilable(T.untyped)
+    ).returns(ActiveRecord::Result)
+  end
+  def upsert_all(attributes, returning: nil, unique_by: nil); end
+
+  sig do
+    params(
+      attributes: T::Hash[T.any(Symbol, String), T.untyped],
+      returning: T.nilable(T.any(FalseClass, T::Array[T.any(Symbol, String)])),
+      unique_by: T.nilable(T.untyped)
+    ).returns(ActiveRecord::Result)
+  end
+  def upsert(attributes, returning: nil, unique_by: nil); end
+end
+
+class ActiveRecord::Result; end
+
+class ActiveRecord::Type::Value
+  extend T::Sig
+
+  sig { params(args: T.untyped).void }
+  def initialize(args); end
+
+  sig { params(value: T.untyped).returns(T.untyped) }
+  def cast(value); end
+end
+
+class ActiveRecord::Type::Boolean < ActiveRecord::Type::Value
+  extend T::Sig
+
+  sig { params(args: T.untyped).void }
+  def initialize(args = nil); end
+
+  sig { params(value: T.untyped).returns(T.nilable(T::Boolean)) }
+  def cast(value); end
+end
+
+module ActiveRecord
+  class ActiveRecordError < StandardError; end
+  class AdapterNotFound < ActiveRecordError; end
+  class AdapterNotSpecified < ActiveRecordError; end
+  class AmbiguousSourceReflectionForThroughAssociation < ActiveRecordError; end
+  class AssociationNotFoundError < ConfigurationError; end
+  class AssociationTypeMismatch < ActiveRecordError; end
+  class AttributeAssignmentError < ActiveRecordError; end
+  class ConcurrentMigrationError < MigrationError; end
+  class ConfigurationError < ActiveRecordError; end
+  class ConnectionNotEstablished < ActiveRecordError; end
+  class ConnectionTimeoutError < ConnectionNotEstablished; end
+  class DangerousAttributeError < ActiveRecordError; end
+  class Deadlocked < TransactionRollbackError; end
+  class DeleteRestrictionError < ActiveRecordError; end
+  class DuplicateMigrationNameError < MigrationError; end
+  class DuplicateMigrationVersionError < MigrationError; end
+  class EagerLoadPolymorphicError < ActiveRecordError; end
+  class EnvironmentMismatchError < ActiveRecordError; end
+  class ExclusiveConnectionTimeoutError < ConnectionTimeoutError; end
+  class FixtureClassNotFound < ActiveRecordError; end
+  class HasManyThroughAssociationNotFoundError < ActiveRecordError; end
+  class HasManyThroughAssociationPointlessSourceTypeError < ActiveRecordError; end
+  class HasManyThroughAssociationPolymorphicSourceError < ActiveRecordError; end
+  class HasManyThroughAssociationPolymorphicThroughError < ActiveRecordError; end
+  class HasManyThroughCantAssociateThroughHasOneOrManyReflection < ThroughCantAssociateThroughHasOneOrManyReflection; end
+  class HasManyThroughNestedAssociationsAreReadonly < ThroughNestedAssociationsAreReadonly; end
+  class HasManyThroughOrderError < ActiveRecordError; end
+  class HasManyThroughSourceAssociationNotFoundError < ActiveRecordError; end
+  class HasOneAssociationPolymorphicThroughError < ActiveRecordError; end
+  class HasOneThroughCantAssociateThroughCollection < ActiveRecordError; end
+  class HasOneThroughCantAssociateThroughHasOneOrManyReflection < ThroughCantAssociateThroughHasOneOrManyReflection; end
+  class HasOneThroughNestedAssociationsAreReadonly < ThroughNestedAssociationsAreReadonly; end
+  class IllegalMigrationNameError < MigrationError; end
+  class ImmutableRelation < ActiveRecordError; end
+  class InvalidForeignKey < WrappedDatabaseException; end
+  class InverseOfAssociationNotFoundError < ActiveRecordError; end
+  class IrreversibleMigration < MigrationError; end
+  class IrreversibleOrderError < ActiveRecordError; end
+  class LockWaitTimeout < StatementInvalid; end
+  class MigrationError < ActiveRecordError; end
+  class MismatchedForeignKey < StatementInvalid; end
+  class MultiparameterAssignmentErrors < ActiveRecordError; end
+  class NoDatabaseError < StatementInvalid; end
+  class NoEnvironmentInSchemaError < MigrationError; end
+  class NotNullViolation < StatementInvalid; end
+  class PendingMigrationError < MigrationError; end
+  class PreparedStatementCacheExpired < StatementInvalid; end
+  class PreparedStatementInvalid < ActiveRecordError; end
+  class ProtectedEnvironmentError < ActiveRecordError; end
+  class QueryCanceled < StatementInvalid; end
+  class RangeError < StatementInvalid; end
+  class ReadOnlyRecord < ActiveRecordError; end
+  class RecordInvalid < ActiveRecordError; end
+  class RecordNotDestroyed < ActiveRecordError; end
+  class RecordNotFound < ActiveRecordError; end
+  class RecordNotSaved < ActiveRecordError; end
+  class RecordNotUnique < WrappedDatabaseException; end
+  class Rollback < ActiveRecordError; end
+  class SerializationFailure < TransactionRollbackError; end
+  class SerializationTypeMismatch < ActiveRecordError; end
+  class StaleObjectError < ActiveRecordError; end
+  class StatementInvalid < ActiveRecordError; end
+  class StatementTimeout < StatementInvalid; end
+  class SubclassNotFound < ActiveRecordError; end
+  class ThroughCantAssociateThroughHasOneOrManyReflection < ActiveRecordError; end
+  class ThroughNestedAssociationsAreReadonly < ActiveRecordError; end
+  class TransactionIsolationError < ActiveRecordError; end
+  class TransactionRollbackError < StatementInvalid; end
+  class TypeConflictError < StandardError; end
+  class UnknownAttributeError < NoMethodError; end
+  class UnknownAttributeReference < ActiveRecordError; end
+  class UnknownMigrationVersionError < MigrationError; end
+  class UnknownPrimaryKey < ActiveRecordError; end
+  class ValueTooLong < StatementInvalid; end
+  class WrappedDatabaseException < StatementInvalid; end
+end
+
+class ActiveRecord::Schema < ActiveRecord::Migration::Current
   sig {params(info: T::Hash[T.untyped, T.untyped], blk: T.proc.bind(ActiveRecord::Schema).void).void}
   def self.define(info = nil, &blk); end
 end
 
+# Method definitions are documented here:
+# https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html
 class ActiveRecord::Migration::Current < ActiveRecord::Migration
-  def change_column(table_name, column_name, type, options = nil); end
-  def create_table(table_name, options = nil); end
+  # Tables
+
+  # https://github.com/rails/rails/blob/v5.2.3/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb#L151-L290
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      comment: T.untyped,
+      id: T.any(T::Boolean, Symbol),
+      primary_key: T.any(String, Symbol, T::Array[T.any(String, Symbol)]),
+      options: T.untyped,
+      temporary: T::Boolean,
+      force: T.any(T::Boolean, Symbol),
+      as: T.untyped,
+      blk: T.nilable(T.proc.params(t: ActiveRecord::ConnectionAdapters::TableDefinition).void)
+    ).returns(T.untyped)
+  end
+  def create_table(
+    table_name,
+    comment: nil,
+    id: :primary_key,
+    primary_key: :_,
+    options: nil,
+    temporary: false,
+    force: false,
+    as: nil,
+    &blk
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      bulk: T::Boolean
+    ).returns(T.untyped)
+  end
+  def change_table(
+    table_name,
+    bulk: false
+  ); end
+
+  sig { params(table_name: T.any(String, Symbol), new_name: T.any(String, Symbol)).returns(T.untyped) }
+  def rename_table(table_name, new_name); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      force: T.any(T::Boolean, Symbol),
+      if_exists: T::Boolean
+    ).returns(T.untyped)
+  end
+  def drop_table(
+    table_name,
+    force: false,
+    if_exists: false
+  ); end
+
+  # Join Tables
+
+  sig do
+    params(
+      table_1: T.any(String, Symbol),
+      table_2: T.any(String, Symbol),
+      column_options: T.untyped,
+      options: T.untyped,
+      table_name: T.untyped,
+      temporary: T.untyped,
+      force: T::Boolean
+    ).returns(T.untyped)
+  end
+  def create_join_table(
+    table_1,
+    table_2,
+    column_options: {},
+    options: nil,
+    table_name: nil,
+    temporary: nil,
+    force: false
+  ); end
+
+  sig { params(table_1: T.any(String, Symbol), table_2: T.any(String, Symbol), options: T.untyped).returns(T.untyped) }
+  def drop_join_table(table_1, table_2, options = {}); end
+
+  # Columns
+
+  sig do
+    params(
+      table_name: T.untyped,
+      column_name: T.untyped,
+      type: T.untyped,
+      limit: T.untyped,
+      default: T.untyped,
+      null: T.untyped,
+      precision: T.untyped,
+      scale: T.untyped,
+      comment: T.untyped
+    ).returns(T.untyped)
+  end
+  def add_column(
+    table_name,
+    column_name,
+    type,
+    limit: nil,
+    default: nil,
+    null: nil,
+    precision: nil,
+    scale: nil,
+    comment: nil
+  ); end
+
+  sig do
+    params(
+      table_name: T.untyped,
+      column_name: T.untyped,
+      type: T.untyped,
+      limit: T.untyped,
+      default: T.untyped,
+      null: T.untyped,
+      precision: T.untyped,
+      scale: T.untyped,
+      comment: T.untyped
+    ).returns(T.untyped)
+  end
+  def change_column(
+    table_name,
+    column_name,
+    type,
+    limit: nil,
+    default: nil,
+    null: nil,
+    precision: nil,
+    scale: nil,
+    comment: nil
+  ); end
+
+  sig do
+    params(
+      table_name: T.untyped,
+      column_name: T.untyped,
+      null: T.untyped,
+      default: T.untyped
+    ).returns(T.untyped)
+  end
+  def change_column_null(table_name, column_name, null, default = nil); end
+
+  sig { params(table_name: T.untyped, column_name: T.untyped, default_or_changes: T.untyped).returns(T.untyped) }
+  def change_column_default(table_name, column_name, default_or_changes); end
+
+  sig { params(table_name: T.untyped, column_name: T.untyped, new_column_name: T.untyped).returns(T.untyped) }
+  def rename_column(table_name, column_name, new_column_name); end
+
+  sig do
+    params(
+      table_name: T.untyped,
+      column_name: T.untyped,
+      type: T.untyped,
+      options: T.untyped
+    ).returns(T.untyped)
+  end
+  def remove_column(
+    table_name,
+    column_name,
+    type = nil,
+    options = {}
+  ); end
+
+  sig { params(table_name: T.any(String, Symbol), column_names: T.untyped).returns(T.untyped) }
+  def remove_columns(table_name, *column_names); end
+
+  # Foreign Keys
+
+  sig do
+    params(
+      from_table: T.untyped,
+      to_table: T.untyped,
+      column: T.untyped,
+      primary_key: T.untyped,
+      name: T.untyped,
+      on_delete: T.untyped,
+      on_update: T.untyped,
+      validate: T.untyped
+    ).returns(T.untyped)
+  end
+  def add_foreign_key(
+    from_table,
+    to_table,
+    column: nil,
+    primary_key: nil,
+    name: nil,
+    on_delete: nil,
+    on_update: nil,
+    validate: nil
+  ); end
+
+  sig do
+    params(
+      from_table: T.untyped,
+      to_table: T.untyped,
+      column: T.untyped,
+      primary_key: T.untyped,
+      name: T.untyped,
+      on_delete: T.untyped,
+      on_update: T.untyped,
+      validate: T.untyped
+    ).returns(T.untyped)
+  end
+  def remove_foreign_key(
+    from_table,
+    to_table,
+    column: nil,
+    primary_key: nil,
+    name: nil,
+    on_delete: nil,
+    on_update: nil,
+    validate: nil
+  ); end
+
+  # Indices
+
+  sig do
+    params(
+      table_name: T.untyped,
+      column_name: T.untyped,
+      using: T.untyped,
+      unique: T.nilable(T::Boolean),
+      where: T.untyped,
+      order: T.untyped,
+      name: T.untyped,
+      length: T.untyped,
+      opclass: T.untyped,
+      type: T.untyped,
+      internal: T.untyped,
+      algorithm: T.untyped
+    ).returns(T.untyped)
+  end
+  def add_index(
+    table_name,
+    column_name,
+    using: nil,
+    unique: nil,
+    where: nil,
+    order: nil,
+    name: nil,
+    length: nil,
+    opclass: nil,
+    type: nil,
+    internal: nil,
+    algorithm: nil
+  ); end
+
+  sig do
+    params(
+      table_name: Symbol,
+      column: T.any(Symbol, T::Array[Symbol]),
+      name: T.nilable(Symbol)
+    ).returns(T.untyped)
+  end
+  def remove_index(
+    table_name,
+    column,
+    name: nil
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      old_name: T.any(String, Symbol),
+      new_name: T.any(String, Symbol)
+    ).returns(T.untyped)
+  end
+  def rename_index(
+    table_name,
+    old_name,
+    new_name
+  ); end
+
+  # References
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      ref_name: T.untyped,
+      type: T.untyped,
+      index: T.untyped,
+      foreign_key: T.untyped,
+      polymorphic: T.untyped,
+      null: T.untyped
+    ).returns(T.untyped)
+  end
+  def add_reference(
+    table_name,
+    ref_name,
+    type: nil,
+    index: nil,
+    foreign_key: nil,
+    polymorphic: nil,
+    null: nil
+  ); end
+
+  sig do
+    params(
+      table_name: T.any(String, Symbol),
+      ref_name: T.untyped,
+      foreign_key: T.untyped,
+      polymorphic: T.untyped,
+      index: T.untyped
+    ).returns(T.untyped)
+  end
+  def remove_reference(
+    table_name,
+    ref_name,
+    foreign_key: false,
+    polymorphic: false,
+    index: nil
+  ); end
+
+  # Timestamps
+
+  sig { params(table_name: T.any(String, Symbol), options: T.untyped).returns(T.untyped) }
+  def add_timestamps(table_name, options = {}); end
+
+  sig { params(table_name: T.any(String, Symbol), options: T.untyped).returns(T.untyped) }
+  def remove_timestamps(table_name, options = {}); end
+
+  # Extensions
+
+  sig { params(name: T.any(String, Symbol)).returns(T.untyped) }
+  def enable_extension(name); end
+
+  sig { params(name: T.any(String, Symbol)).returns(T.untyped) }
+  def disable_extension(name); end
+
+  # Miscellaneous
+
+  sig { params(message: String, subitem: T.untyped).void }
+  def say(message, subitem = false); end
+
+  sig { params(message: String).returns(T.untyped) }
+  def say_with_time(message); end
+
+  sig { void }
+  def suppress_messages; end
+
+  sig { returns(T.untyped) }
+  def reversible(); end
+
+  sig { params(migration_classes: T.untyped).returns(T.untyped) }
+  def revert(*migration_classes); end
+
+  sig { params(sql: String, name: T.nilable(String)).returns(T.untyped) }
+  def execute(sql, name = nil); end
+end
+
+module ActiveRecord::AttributeMethods::Dirty
+  extend T::Sig
+  sig { params(attr_name: Symbol, options: T.untyped).returns(T::Boolean) }
+  def saved_change_to_attribute?(attr_name, **options); end
+end
+
+module ActiveRecord::Associations
+  mixes_in_class_methods(ActiveRecord::Associations::ClassMethods)
+end
+
+module ActiveRecord::Validations
+  include ActiveModel::Validations
+
+  mixes_in_class_methods(ActiveModel::Validations::ClassMethods)
 end