sorbet-rails 0.5.1 → 0.5.2

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

@@ -1,422 +0,0 @@
-# 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

@@ -1,17 +0,0 @@
-# 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

@@ -1,1263 +0,0 @@
-# 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/all/activerecord.rbi
-#
-# 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
-
-  sig do
-    params(
-      name: T.nilable(T.any(Symbol, String)),
-      scope: T.nilable(T.proc.void),
-      autosave: T.nilable(T::Boolean),
-      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),
-      default: T.nilable(T.proc.returns(T.untyped))
-    ).void
-  end
-  def belongs_to(
-    name,
-    scope = nil,
-    autosave: nil,
-    class_name: nil,
-    counter_cache: nil,
-    dependent: nil,
-    foreign_key: nil,
-    foreign_type: nil,
-    inverse_of: nil,
-    optional: nil,
-    polymorphic: nil,
-    primary_key: nil,
-    required: nil,
-    touch: nil,
-    validate: 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
-
-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
-  # 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