rbs_rails 0.3.0 → 0.4.0

data/assets/sig/generated/activemodel.rbs

@@ -1,3 +1,152 @@
+module ActiveModel
+  class Attribute
+    class UserProvidedDefault < FromUser
+      # :nodoc:
+      # :nodoc:
+      def initialize: (untyped name, untyped value, untyped `type`, untyped database_default) -> untyped
+
+      def value_before_type_cast: () -> untyped
+
+      def with_type: (untyped `type`) -> untyped
+
+      def marshal_dump: () -> untyped
+
+      def marshal_load: (untyped values) -> untyped
+
+      attr_reader user_provided_value: untyped
+    end
+  end
+end
+
+module ActiveModel
+  class Attribute
+    def self.from_database: (untyped name, untyped value, untyped `type`) -> FromDatabase
+
+    def self.from_user: (untyped name, untyped value, untyped `type`, ?untyped? original_attribute) -> FromUser
+
+    def self.with_cast_value: (untyped name, untyped value, untyped `type`) -> WithCastValue
+
+    def self.null: (untyped name) -> Null
+
+    def self.uninitialized: (untyped name, untyped `type`) -> Uninitialized
+
+    attr_reader name: untyped
+
+    attr_reader value_before_type_cast: untyped
+
+    attr_reader type: untyped
+
+    # This method should not be called directly.
+    # Use #from_database or #from_user
+    def initialize: (untyped name, untyped value_before_type_cast, untyped `type`, ?untyped? original_attribute) -> untyped
+
+    def value: () -> untyped
+
+    def original_value: () -> untyped
+
+    def value_for_database: () -> untyped
+
+    def changed?: () -> untyped
+
+    def changed_in_place?: () -> untyped
+
+    def forgetting_assignment: () -> untyped
+
+    def with_value_from_user: (untyped value) -> untyped
+
+    def with_value_from_database: (untyped value) -> untyped
+
+    def with_cast_value: (untyped value) -> untyped
+
+    def with_type: (untyped `type`) -> untyped
+
+    def type_cast: () -> untyped
+
+    def initialized?: () -> ::TrueClass
+
+    def came_from_user?: () -> ::FalseClass
+
+    def has_been_read?: () -> untyped
+
+    def ==: (untyped other) -> untyped
+
+    alias eql? ==
+
+    def hash: () -> untyped
+
+    def init_with: (untyped coder) -> untyped
+
+    def encode_with: (untyped coder) -> untyped
+
+    def original_value_for_database: () -> untyped
+
+    attr_reader original_attribute: untyped
+
+    alias assigned? original_attribute
+
+    def initialize_dup: (untyped other) -> untyped
+
+    def changed_from_assignment?: () -> untyped
+
+    def _original_value_for_database: () -> untyped
+
+    class FromDatabase < Attribute
+      # :nodoc:
+      def type_cast: (untyped value) -> untyped
+
+      def _original_value_for_database: () -> untyped
+    end
+
+    class FromUser < Attribute
+      # :nodoc:
+      def type_cast: (untyped value) -> untyped
+
+      def came_from_user?: () -> untyped
+    end
+
+    class WithCastValue < Attribute
+      # :nodoc:
+      def type_cast: (untyped value) -> untyped
+
+      def changed_in_place?: () -> ::FalseClass
+    end
+
+    class Null < Attribute
+      # :nodoc:
+      def initialize: (untyped name) -> untyped
+
+      def type_cast: () -> nil
+
+      def with_type: (untyped `type`) -> untyped
+
+      def with_value_from_database: (untyped value) -> untyped
+
+      alias with_value_from_user with_value_from_database
+
+      alias with_cast_value with_value_from_database
+    end
+
+    class Uninitialized < Attribute
+      # :nodoc:
+      UNINITIALIZED_ORIGINAL_VALUE: untyped
+
+      def initialize: (untyped name, untyped `type`) -> untyped
+
+      def value: () { (untyped) -> untyped } -> untyped
+
+      def original_value: () -> untyped
+
+      def value_for_database: () -> nil
+
+      def initialized?: () -> ::FalseClass
+
+      def forgetting_assignment: () -> untyped
+
+      def with_type: (untyped `type`) -> untyped
+    end
+  end
+end
+
 module ActiveModel
   module AttributeAssignment
     include ActiveModel::ForbiddenAttributesProtection
@@ -23,6 +172,8 @@ module ActiveModel
     #   cat.status # => 'sleeping'
     def assign_attributes: (untyped new_attributes) -> (nil | untyped)
 
+    alias attributes= assign_attributes
+
     def _assign_attributes: (untyped attributes) -> untyped
 
     def _assign_attribute: (untyped k, untyped v) -> untyped
@@ -341,7 +492,7 @@ module ActiveModel
         # nodoc:
         attr_reader target: untyped
 
-        class AttributeMethodMatch < ::Struct[untyped]
+        class AttributeMethodMatch[T] < ::Struct[T]
           attr_accessor target(): untyped
 
           attr_accessor attr_name(): untyped
@@ -375,6 +526,11 @@ module ActiveModel
     # attribute. This method can be overloaded to customize the behavior.
     def attribute_missing: (untyped match, *untyped args) { () -> untyped } -> untyped
 
+    # A +Person+ instance with a +name+ attribute can ask
+    # <tt>person.respond_to?(:name)</tt>, <tt>person.respond_to?(:name=)</tt>,
+    # and <tt>person.respond_to?(:name?)</tt> which will all return +true+.
+    alias respond_to_without_attributes? respond_to?
+
     def respond_to?: (untyped method, ?bool include_private_methods) -> untyped
 
     def attribute_method?: (untyped attr_name) -> untyped
@@ -431,7 +587,7 @@ module ActiveModel
 
     def any_changes?: () -> untyped
 
-    def changed?: (untyped attr_name, ?to: untyped to, ?from: untyped from) -> untyped
+    def changed?: (untyped attr_name, ?from: untyped from, ?to: untyped to) -> untyped
 
     def changed_in_place?: (untyped attr_name) -> untyped
 
@@ -502,205 +658,103 @@ module ActiveModel
 end
 
 module ActiveModel
-  class Attribute
-    def self.from_database: (untyped name, untyped value, untyped `type`) -> FromDatabase
+  class AttributeSet
+    class Builder
+      # :nodoc:
+      # :nodoc:
+      attr_reader types: untyped
 
-    def self.from_user: (untyped name, untyped value, untyped `type`, ?untyped? original_attribute) -> FromUser
+      # :nodoc:
+      # :nodoc:
+      attr_reader default_attributes: untyped
 
-    def self.with_cast_value: (untyped name, untyped value, untyped `type`) -> WithCastValue
+      def initialize: (untyped types, ?::Hash[untyped, untyped] default_attributes) -> untyped
 
-    def self.null: (untyped name) -> Null
+      def build_from_database: (?::Hash[untyped, untyped] values, ?::Hash[untyped, untyped] additional_types) -> AttributeSet
+    end
+  end
 
-    def self.uninitialized: (untyped name, untyped `type`) -> Uninitialized
+  class LazyAttributeHash
+    def initialize: (untyped types, untyped values, untyped additional_types, untyped default_attributes, ?::Hash[untyped, untyped] delegate_hash) -> untyped
 
-    attr_reader name: untyped
+    def key?: (untyped key) -> untyped
 
-    attr_reader value_before_type_cast: untyped
+    def []: (untyped key) -> untyped
 
-    attr_reader type: untyped
+    def []=: (untyped key, untyped value) -> untyped
 
-    # This method should not be called directly.
-    # Use #from_database or #from_user
-    def initialize: (untyped name, untyped value_before_type_cast, untyped `type`, ?untyped? original_attribute) -> untyped
+    def deep_dup: () -> untyped
 
-    def value: () -> untyped
+    def initialize_dup: (untyped _) -> untyped
 
-    def original_value: () -> untyped
+    def select: () { (untyped, untyped) -> untyped } -> untyped
 
-    def value_for_database: () -> untyped
+    def ==: (untyped other) -> untyped
 
-    def changed?: () -> untyped
+    def marshal_dump: () -> ::Array[untyped]
 
-    def changed_in_place?: () -> untyped
+    def marshal_load: (untyped values) -> untyped
 
-    def forgetting_assignment: () -> untyped
+    def materialize: () -> untyped
 
-    def with_value_from_user: (untyped value) -> untyped
+    attr_reader types: untyped
 
-    def with_value_from_database: (untyped value) -> untyped
+    attr_reader values: untyped
 
-    def with_cast_value: (untyped value) -> untyped
+    attr_reader additional_types: untyped
 
-    def with_type: (untyped `type`) -> untyped
+    attr_reader delegate_hash: untyped
 
-    def type_cast: () -> untyped
+    attr_reader default_attributes: untyped
 
-    def initialized?: () -> ::TrueClass
+    def assign_default_value: (untyped name) -> untyped
+  end
+end
 
-    def came_from_user?: () -> ::FalseClass
+module ActiveModel
+  class AttributeSet
+    class YAMLEncoder
+      # Attempts to do more intelligent YAML dumping of an
+      # ActiveModel::AttributeSet to reduce the size of the resulting string
+      # :nodoc:
+      def initialize: (untyped default_types) -> untyped
 
-    def has_been_read?: () -> untyped
+      def encode: (untyped attribute_set, untyped coder) -> untyped
 
-    def ==: (untyped other) -> untyped
+      def decode: (untyped coder) -> untyped
 
-    def hash: () -> untyped
+      attr_reader default_types: untyped
+    end
+  end
+end
 
-    def init_with: (untyped coder) -> untyped
+module ActiveModel
+  class AttributeSet
+    def initialize: (untyped attributes) -> untyped
 
-    def encode_with: (untyped coder) -> untyped
+    def []: (untyped name) -> untyped
 
-    def original_value_for_database: () -> untyped
+    def []=: (untyped name, untyped value) -> untyped
 
-    attr_reader original_attribute: untyped
+    def values_before_type_cast: () -> untyped
 
-    def initialize_dup: (untyped other) -> untyped
+    def to_hash: () -> untyped
 
-    def changed_from_assignment?: () -> untyped
+    alias to_h to_hash
 
-    def _original_value_for_database: () -> untyped
+    def key?: (untyped name) -> untyped
 
-    class FromDatabase < Attribute
-      # :nodoc:
-      def type_cast: (untyped value) -> untyped
+    def keys: () -> untyped
 
-      def _original_value_for_database: () -> untyped
-    end
+    def fetch_value: (untyped name) { () -> untyped } -> untyped
 
-    class FromUser < Attribute
-      # :nodoc:
-      def type_cast: (untyped value) -> untyped
+    def write_from_database: (untyped name, untyped value) -> untyped
 
-      def came_from_user?: () -> untyped
-    end
+    def write_from_user: (untyped name, untyped value) -> untyped
 
-    class WithCastValue < Attribute
-      # :nodoc:
-      def type_cast: (untyped value) -> untyped
+    def write_cast_value: (untyped name, untyped value) -> untyped
 
-      def changed_in_place?: () -> ::FalseClass
-    end
-
-    class Null < Attribute
-      # :nodoc:
-      def initialize: (untyped name) -> untyped
-
-      def type_cast: () -> nil
-
-      def with_type: (untyped `type`) -> untyped
-
-      def with_value_from_database: (untyped value) -> untyped
-    end
-
-    class Uninitialized < Attribute
-      # :nodoc:
-      UNINITIALIZED_ORIGINAL_VALUE: untyped
-
-      def initialize: (untyped name, untyped `type`) -> untyped
-
-      def value: () { (untyped) -> untyped } -> untyped
-
-      def original_value: () -> untyped
-
-      def value_for_database: () -> nil
-
-      def initialized?: () -> ::FalseClass
-
-      def forgetting_assignment: () -> untyped
-
-      def with_type: (untyped `type`) -> untyped
-    end
-  end
-end
-
-module ActiveModel
-  class AttributeSet
-    class Builder
-      # :nodoc:
-      # :nodoc:
-      attr_reader types: untyped
-
-      # :nodoc:
-      # :nodoc:
-      attr_reader default_attributes: untyped
-
-      def initialize: (untyped types, ?::Hash[untyped, untyped] default_attributes) -> untyped
-
-      def build_from_database: (?::Hash[untyped, untyped] values, ?::Hash[untyped, untyped] additional_types) -> AttributeSet
-    end
-  end
-
-  class LazyAttributeHash
-    def initialize: (untyped types, untyped values, untyped additional_types, untyped default_attributes, ?::Hash[untyped, untyped] delegate_hash) -> untyped
-
-    def key?: (untyped key) -> untyped
-
-    def []: (untyped key) -> untyped
-
-    def []=: (untyped key, untyped value) -> untyped
-
-    def deep_dup: () -> untyped
-
-    def initialize_dup: (untyped _) -> untyped
-
-    def select: () { (untyped, untyped) -> untyped } -> untyped
-
-    def ==: (untyped other) -> untyped
-
-    def marshal_dump: () -> ::Array[untyped]
-
-    def marshal_load: (untyped values) -> untyped
-
-    def materialize: () -> untyped
-
-    attr_reader types: untyped
-
-    attr_reader values: untyped
-
-    attr_reader additional_types: untyped
-
-    attr_reader delegate_hash: untyped
-
-    attr_reader default_attributes: untyped
-
-    def assign_default_value: (untyped name) -> untyped
-  end
-end
-
-module ActiveModel
-  class AttributeSet
-    def initialize: (untyped attributes) -> untyped
-
-    def []: (untyped name) -> untyped
-
-    def []=: (untyped name, untyped value) -> untyped
-
-    def values_before_type_cast: () -> untyped
-
-    def to_hash: () -> untyped
-
-    def key?: (untyped name) -> untyped
-
-    def keys: () -> untyped
-
-    def fetch_value: (untyped name) { () -> untyped } -> untyped
-
-    def write_from_database: (untyped name, untyped value) -> untyped
-
-    def write_from_user: (untyped name, untyped value) -> untyped
-
-    def write_cast_value: (untyped name, untyped value) -> untyped
-
-    def freeze: () -> untyped
+    def freeze: () -> untyped
 
     def deep_dup: () -> untyped
 
@@ -722,23 +776,6 @@ module ActiveModel
   end
 end
 
-module ActiveModel
-  class AttributeSet
-    class YAMLEncoder
-      # Attempts to do more intelligent YAML dumping of an
-      # ActiveModel::AttributeSet to reduce the size of the resulting string
-      # :nodoc:
-      def initialize: (untyped default_types) -> untyped
-
-      def encode: (untyped attribute_set, untyped coder) -> untyped
-
-      def decode: (untyped coder) -> untyped
-
-      attr_reader default_types: untyped
-    end
-  end
-end
-
 module ActiveModel
   module Attributes
     # nodoc:
@@ -811,26 +848,6 @@ module ActiveModel
   end
 end
 
-module ActiveModel
-  class Attribute
-    class UserProvidedDefault < FromUser
-      # :nodoc:
-      # :nodoc:
-      def initialize: (untyped name, untyped value, untyped `type`, untyped database_default) -> untyped
-
-      def value_before_type_cast: () -> untyped
-
-      def with_type: (untyped `type`) -> untyped
-
-      def marshal_dump: () -> untyped
-
-      def marshal_load: (untyped values) -> untyped
-
-      attr_reader user_provided_value: untyped
-    end
-  end
-end
-
 module ActiveModel
   # == Active \Model \Callbacks
   #
@@ -1344,6 +1361,10 @@ module ActiveModel
     #   person.errors.include?(:age)  # => false
     def include?: (untyped attribute) -> untyped
 
+    alias has_key? include?
+
+    alias key? include?
+
     # Delete messages for +key+. Returns the deleted messages.
     #
     #   person.errors[:name]        # => ["cannot be nil"]
@@ -1382,6 +1403,8 @@ module ActiveModel
     #   person.errors.size # => 2
     def size: () -> untyped
 
+    alias count size
+
     # Returns all message values.
     #
     #   person.errors.messages # => {:name=>["cannot be nil", "must be specified"]}
@@ -1401,6 +1424,8 @@ module ActiveModel
     #   person.errors.empty?        # => false
     def empty?: () -> untyped
 
+    alias blank? empty?
+
     # Returns an xml formatted representation of the Errors hash.
     #
     #   person.errors.add(:name, :blank, message: "can't be blank")
@@ -1515,6 +1540,8 @@ module ActiveModel
     #   # => ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Email can't be blank"]
     def full_messages: () -> untyped
 
+    alias to_a full_messages
+
     # Returns all the full error messages for a given attribute in an array.
     #
     #   class Person
@@ -1640,6 +1667,8 @@ module ActiveModel
 
   module ForbiddenAttributesProtection
     def sanitize_for_mass_assignment: (untyped attributes) -> untyped
+
+    alias sanitize_forbidden_attributes sanitize_for_mass_assignment
   end
 end
 
@@ -1863,6 +1892,8 @@ module ActiveModel
 
     attr_reader name: untyped
 
+    alias cache_key collection
+
     # Returns a new ActiveModel::Name instance. By default, the +namespace+
     # and +name+ option will take the namespace and name of the given class
     # respectively.
@@ -1987,16 +2018,6 @@ module ActiveModel
   end
 end
 
-module ActiveModel
-  extend ActiveSupport::Autoload
-
-  module Serializers
-    extend ActiveSupport::Autoload
-  end
-
-  def self.eager_load!: () -> untyped
-end
-
 module ActiveModel
   module SecurePassword
     extend ActiveSupport::Concern
@@ -2183,6 +2204,24 @@ module ActiveModel
     #   # => {"name" => "Napoleon", "notes" => [{"title"=>"Battle of Austerlitz"}]}
     def serializable_hash: (?untyped? options) -> untyped
 
+    # Hook method defining how an attribute value should be retrieved for
+    # serialization. By default this is assumed to be an instance named after
+    # the attribute. Override this method in subclasses should you need to
+    # retrieve the value for a given attribute differently:
+    #
+    #   class MyClass
+    #     include ActiveModel::Serialization
+    #
+    #     def initialize(data = {})
+    #       @data = data
+    #     end
+    #
+    #     def read_attribute_for_serialization(key)
+    #       @data[key]
+    #     end
+    #   end
+    alias read_attribute_for_serialization send
+
     def serializable_add_includes: (?::Hash[untyped, untyped] options) { (untyped, untyped, untyped) -> untyped } -> (nil | untyped)
   end
 end
@@ -2378,6 +2417,8 @@ module ActiveModel
 
         def to_s: () -> untyped
 
+        alias to_str to_s
+
         def hex: () -> untyped
 
         def ==: (untyped other) -> untyped
@@ -2628,19 +2669,6 @@ module ActiveModel
   end
 end
 
-module ActiveModel
-  module Type
-    attr_accessor registry: untyped
-
-    # Add a new type to the registry, allowing it to be gotten through ActiveModel::Type#lookup
-    def self.register: (untyped type_name, ?untyped? klass, **untyped options) { () -> untyped } -> untyped
-
-    def self.lookup: (*untyped args, **untyped kwargs) -> untyped
-
-    def self.default_value: () -> untyped
-  end
-end
-
 module ActiveModel
   # :stopdoc:
   module Type
@@ -2710,7 +2738,7 @@ module ActiveModel
 
       attr_reader limit: untyped
 
-      def initialize: (?scale: untyped? scale, ?limit: untyped? limit, ?precision: untyped? precision) -> untyped
+      def initialize: (?precision: untyped? precision, ?limit: untyped? limit, ?scale: untyped? scale) -> untyped
 
       def `type`: () -> nil
 
@@ -2776,6 +2804,8 @@ module ActiveModel
 
       def ==: (untyped other) -> untyped
 
+      alias eql? ==
+
       def hash: () -> untyped
 
       def assert_valid_value: () -> nil
@@ -2785,6 +2815,19 @@ module ActiveModel
   end
 end
 
+module ActiveModel
+  module Type
+    attr_accessor registry: untyped
+
+    # Add a new type to the registry, allowing it to be gotten through ActiveModel::Type#lookup
+    def self.register: (untyped type_name, ?untyped? klass, **untyped options) { () -> untyped } -> untyped
+
+    def self.lookup: (*untyped args, **untyped kwargs) -> untyped
+
+    def self.default_value: () -> untyped
+  end
+end
+
 module ActiveModel
   module Validations
     class AbsenceValidator < EachValidator
@@ -3267,6 +3310,8 @@ module ActiveModel
       # +:if+, +:unless+, +:on+ and +:strict+.
       # See <tt>ActiveModel::Validations#validates</tt> for more information
       def validates_length_of: (*untyped attr_names) -> untyped
+
+      alias validates_size_of validates_length_of
     end
   end
 end
@@ -3395,357 +3440,14 @@ module ActiveModel
 end
 
 module ActiveModel
-  # == Active \Model \Validations
-  #
-  # Provides a full validation framework to your objects.
-  #
-  # A minimal implementation could be:
-  #
-  #   class Person
-  #     include ActiveModel::Validations
-  #
-  #     attr_accessor :first_name, :last_name
-  #
-  #     validates_each :first_name, :last_name do |record, attr, value|
-  #       record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
-  #     end
-  #   end
-  #
-  # Which provides you with the full standard validation stack that you
-  # know from Active Record:
-  #
-  #   person = Person.new
-  #   person.valid?                   # => true
-  #   person.invalid?                 # => false
-  #
-  #   person.first_name = 'zoolander'
-  #   person.valid?                   # => false
-  #   person.invalid?                 # => true
-  #   person.errors.messages          # => {first_name:["starts with z."]}
-  #
-  # Note that <tt>ActiveModel::Validations</tt> automatically adds an +errors+
-  # method to your instances initialized with a new <tt>ActiveModel::Errors</tt>
-  # object, so there is no need for you to do this manually.
   module Validations
-    extend ActiveSupport::Concern
-
-    extend ActiveModel::Naming
-
-    extend ActiveModel::Callbacks
-
-    extend ActiveModel::Translation
-
-    extend HelperMethods
-
-    include HelperMethods
-
-    attr_accessor validation_context: untyped
-
     module ClassMethods
-      # Validates each attribute against a block.
+      # This method is a shortcut to all default validators and any custom
+      # validator classes ending in 'Validator'. Note that Rails default
+      # validators can be overridden inside specific classes by creating
+      # custom validator classes in their place such as PresenceValidator.
       #
-      #   class Person
-      #     include ActiveModel::Validations
-      #
-      #     attr_accessor :first_name, :last_name
-      #
-      #     validates_each :first_name, :last_name, allow_blank: true do |record, attr, value|
-      #       record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
-      #     end
-      #   end
-      #
-      # Options:
-      # * <tt>:on</tt> - Specifies the contexts where this validation is active.
-      #   Runs in all validation contexts by default +nil+. You can pass a symbol
-      #   or an array of symbols. (e.g. <tt>on: :create</tt> or
-      #   <tt>on: :custom_validation_context</tt> or
-      #   <tt>on: [:create, :custom_validation_context]</tt>)
-      # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+.
-      # * <tt>:allow_blank</tt> - Skip validation if attribute is blank.
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
-      #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
-      #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
-      #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
-      #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
-      #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
-      #   method, proc or string should return or evaluate to a +true+ or +false+
-      #   value.
-      def validates_each: (*untyped attr_names) { () -> untyped } -> untyped
-
-      VALID_OPTIONS_FOR_VALIDATE: untyped
-
-      # Adds a validation method or block to the class. This is useful when
-      # overriding the +validate+ instance method becomes too unwieldy and
-      # you're looking for more descriptive declaration of your validations.
-      #
-      # This can be done with a symbol pointing to a method:
-      #
-      #   class Comment
-      #     include ActiveModel::Validations
-      #
-      #     validate :must_be_friends
-      #
-      #     def must_be_friends
-      #       errors.add(:base, 'Must be friends to leave a comment') unless commenter.friend_of?(commentee)
-      #     end
-      #   end
-      #
-      # With a block which is passed with the current record to be validated:
-      #
-      #   class Comment
-      #     include ActiveModel::Validations
-      #
-      #     validate do |comment|
-      #       comment.must_be_friends
-      #     end
-      #
-      #     def must_be_friends
-      #       errors.add(:base, 'Must be friends to leave a comment') unless commenter.friend_of?(commentee)
-      #     end
-      #   end
-      #
-      # Or with a block where self points to the current record to be validated:
-      #
-      #   class Comment
-      #     include ActiveModel::Validations
-      #
-      #     validate do
-      #       errors.add(:base, 'Must be friends to leave a comment') unless commenter.friend_of?(commentee)
-      #     end
-      #   end
-      #
-      # Note that the return value of validation methods is not relevant.
-      # It's not possible to halt the validate callback chain.
-      #
-      # Options:
-      # * <tt>:on</tt> - Specifies the contexts where this validation is active.
-      #   Runs in all validation contexts by default +nil+. You can pass a symbol
-      #   or an array of symbols. (e.g. <tt>on: :create</tt> or
-      #   <tt>on: :custom_validation_context</tt> or
-      #   <tt>on: [:create, :custom_validation_context]</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
-      #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
-      #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
-      #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
-      #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
-      #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
-      #   method, proc or string should return or evaluate to a +true+ or +false+
-      #   value.
-      #
-      # NOTE: Calling +validate+ multiple times on the same method will overwrite previous definitions.
-      #
-      def validate: (*untyped args) { () -> untyped } -> untyped
-
-      # List all validators that are being used to validate the model using
-      # +validates_with+ method.
-      #
-      #   class Person
-      #     include ActiveModel::Validations
-      #
-      #     validates_with MyValidator
-      #     validates_with OtherValidator, on: :create
-      #     validates_with StrictValidator, strict: true
-      #   end
-      #
-      #   Person.validators
-      #   # => [
-      #   #      #<MyValidator:0x007fbff403e808 @options={}>,
-      #   #      #<OtherValidator:0x007fbff403d930 @options={on: :create}>,
-      #   #      #<StrictValidator:0x007fbff3204a30 @options={strict:true}>
-      #   #    ]
-      def validators: () -> untyped
-
-      # Clears all of the validators and validations.
-      #
-      # Note that this will clear anything that is being used to validate
-      # the model for both the +validates_with+ and +validate+ methods.
-      # It clears the validators that are created with an invocation of
-      # +validates_with+ and the callbacks that are set by an invocation
-      # of +validate+.
-      #
-      #   class Person
-      #     include ActiveModel::Validations
-      #
-      #     validates_with MyValidator
-      #     validates_with OtherValidator, on: :create
-      #     validates_with StrictValidator, strict: true
-      #     validate :cannot_be_robot
-      #
-      #     def cannot_be_robot
-      #       errors.add(:base, 'A person cannot be a robot') if person_is_robot
-      #     end
-      #   end
-      #
-      #   Person.validators
-      #   # => [
-      #   #      #<MyValidator:0x007fbff403e808 @options={}>,
-      #   #      #<OtherValidator:0x007fbff403d930 @options={on: :create}>,
-      #   #      #<StrictValidator:0x007fbff3204a30 @options={strict:true}>
-      #   #    ]
-      #
-      # If one runs <tt>Person.clear_validators!</tt> and then checks to see what
-      # validators this class has, you would obtain:
-      #
-      #   Person.validators # => []
-      #
-      # Also, the callback set by <tt>validate :cannot_be_robot</tt> will be erased
-      # so that:
-      #
-      #   Person._validate_callbacks.empty?  # => true
-      #
-      def clear_validators!: () -> untyped
-
-      # List all validators that are being used to validate a specific attribute.
-      #
-      #   class Person
-      #     include ActiveModel::Validations
-      #
-      #     attr_accessor :name , :age
-      #
-      #     validates_presence_of :name
-      #     validates_inclusion_of :age, in: 0..99
-      #   end
-      #
-      #   Person.validators_on(:name)
-      #   # => [
-      #   #       #<ActiveModel::Validations::PresenceValidator:0x007fe604914e60 @attributes=[:name], @options={}>,
-      #   #    ]
-      def validators_on: (*untyped attributes) -> untyped
-
-      # Returns +true+ if +attribute+ is an attribute method, +false+ otherwise.
-      #
-      #  class Person
-      #    include ActiveModel::Validations
-      #
-      #    attr_accessor :name
-      #  end
-      #
-      #  User.attribute_method?(:name) # => true
-      #  User.attribute_method?(:age)  # => false
-      def attribute_method?: (untyped attribute) -> untyped
-
-      def inherited: (untyped base) -> untyped
-    end
-
-    def initialize_dup: (untyped other) -> untyped
-
-    # Returns the +Errors+ object that holds all information about attribute
-    # error messages.
-    #
-    #   class Person
-    #     include ActiveModel::Validations
-    #
-    #     attr_accessor :name
-    #     validates_presence_of :name
-    #   end
-    #
-    #   person = Person.new
-    #   person.valid? # => false
-    #   person.errors # => #<ActiveModel::Errors:0x007fe603816640 @messages={name:["can't be blank"]}>
-    def errors: () -> untyped
-
-    # Runs all the specified validations and returns +true+ if no errors were
-    # added otherwise +false+.
-    #
-    #   class Person
-    #     include ActiveModel::Validations
-    #
-    #     attr_accessor :name
-    #     validates_presence_of :name
-    #   end
-    #
-    #   person = Person.new
-    #   person.name = ''
-    #   person.valid? # => false
-    #   person.name = 'david'
-    #   person.valid? # => true
-    #
-    # Context can optionally be supplied to define which callbacks to test
-    # against (the context is defined on the validations using <tt>:on</tt>).
-    #
-    #   class Person
-    #     include ActiveModel::Validations
-    #
-    #     attr_accessor :name
-    #     validates_presence_of :name, on: :new
-    #   end
-    #
-    #   person = Person.new
-    #   person.valid?       # => true
-    #   person.valid?(:new) # => false
-    def valid?: (?untyped? context) -> untyped
-
-    # Performs the opposite of <tt>valid?</tt>. Returns +true+ if errors were
-    # added, +false+ otherwise.
-    #
-    #   class Person
-    #     include ActiveModel::Validations
-    #
-    #     attr_accessor :name
-    #     validates_presence_of :name
-    #   end
-    #
-    #   person = Person.new
-    #   person.name = ''
-    #   person.invalid? # => true
-    #   person.name = 'david'
-    #   person.invalid? # => false
-    #
-    # Context can optionally be supplied to define which callbacks to test
-    # against (the context is defined on the validations using <tt>:on</tt>).
-    #
-    #   class Person
-    #     include ActiveModel::Validations
-    #
-    #     attr_accessor :name
-    #     validates_presence_of :name, on: :new
-    #   end
-    #
-    #   person = Person.new
-    #   person.invalid?       # => false
-    #   person.invalid?(:new) # => true
-    def invalid?: (?untyped? context) -> untyped
-
-    # Runs all the validations within the specified context. Returns +true+ if
-    # no errors are found, raises +ValidationError+ otherwise.
-    #
-    # Validations with no <tt>:on</tt> option will run no matter the context. Validations with
-    # some <tt>:on</tt> option will only run in the specified context.
-    def validate!: (?untyped? context) -> untyped
-
-    def run_validations!: () -> untyped
-
-    def raise_validation_error: () -> untyped
-  end
-
-  # = Active Model ValidationError
-  #
-  # Raised by <tt>validate!</tt> when the model is invalid. Use the
-  # +model+ method to retrieve the record which did not validate.
-  #
-  #   begin
-  #     complex_operation_that_internally_calls_validate!
-  #   rescue ActiveModel::ValidationError => invalid
-  #     puts invalid.model.errors
-  #   end
-  class ValidationError < StandardError
-    attr_reader model: untyped
-
-    def initialize: (untyped model) -> untyped
-  end
-end
-
-module ActiveModel
-  module Validations
-    module ClassMethods
-      # This method is a shortcut to all default validators and any custom
-      # validator classes ending in 'Validator'. Note that Rails default
-      # validators can be overridden inside specific classes by creating
-      # custom validator classes in their place such as PresenceValidator.
-      #
-      # Examples of using the default rails validators:
+      # Examples of using the default rails validators:
       #
       #   validates :terms, acceptance: true
       #   validates :password, confirmation: true
@@ -3897,14 +3599,214 @@ module ActiveModel
       #       end
       #   end
       #
-      # You may also pass it multiple classes, like so:
+      # You may also pass it multiple classes, like so:
+      #
+      #   class Person
+      #     include ActiveModel::Validations
+      #     validates_with MyValidator, MyOtherValidator, on: :create
+      #   end
+      #
+      # Configuration options:
+      # * <tt>:on</tt> - Specifies the contexts where this validation is active.
+      #   Runs in all validation contexts by default +nil+. You can pass a symbol
+      #   or an array of symbols. (e.g. <tt>on: :create</tt> or
+      #   <tt>on: :custom_validation_context</tt> or
+      #   <tt>on: [:create, :custom_validation_context]</tt>)
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
+      #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>).
+      #   The method, proc or string should return or evaluate to a +true+ or
+      #   +false+ value.
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+      #   determine if the validation should not occur
+      #   (e.g. <tt>unless: :skip_validation</tt>, or
+      #   <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>).
+      #   The method, proc or string should return or evaluate to a +true+ or
+      #   +false+ value.
+      # * <tt>:strict</tt> - Specifies whether validation should be strict.
+      #   See <tt>ActiveModel::Validations#validates!</tt> for more information.
+      #
+      # If you pass any additional configuration options, they will be passed
+      # to the class and available as +options+:
+      #
+      #   class Person
+      #     include ActiveModel::Validations
+      #     validates_with MyValidator, my_custom_key: 'my custom value'
+      #   end
+      #
+      #   class MyValidator < ActiveModel::Validator
+      #     def validate(record)
+      #       options[:my_custom_key] # => "my custom value"
+      #     end
+      #   end
+      def validates_with: (*untyped args) { () -> untyped } -> untyped
+    end
+
+    # Passes the record off to the class or classes specified and allows them
+    # to add errors based on more complex conditions.
+    #
+    #   class Person
+    #     include ActiveModel::Validations
+    #
+    #     validate :instance_validations
+    #
+    #     def instance_validations
+    #       validates_with MyValidator
+    #     end
+    #   end
+    #
+    # Please consult the class method documentation for more information on
+    # creating your own validator.
+    #
+    # You may also pass it multiple classes, like so:
+    #
+    #   class Person
+    #     include ActiveModel::Validations
+    #
+    #     validate :instance_validations, on: :create
+    #
+    #     def instance_validations
+    #       validates_with MyValidator, MyOtherValidator
+    #     end
+    #   end
+    #
+    # Standard configuration options (<tt>:on</tt>, <tt>:if</tt> and
+    # <tt>:unless</tt>), which are available on the class version of
+    # +validates_with+, should instead be placed on the +validates+ method
+    # as these are applied and tested in the callback.
+    #
+    # If you pass any additional configuration options, they will be passed
+    # to the class and available as +options+, please refer to the
+    # class version of this method for more information.
+    def validates_with: (*untyped args) { () -> untyped } -> untyped
+  end
+end
+
+module ActiveModel
+  # == Active \Model \Validations
+  #
+  # Provides a full validation framework to your objects.
+  #
+  # A minimal implementation could be:
+  #
+  #   class Person
+  #     include ActiveModel::Validations
+  #
+  #     attr_accessor :first_name, :last_name
+  #
+  #     validates_each :first_name, :last_name do |record, attr, value|
+  #       record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
+  #     end
+  #   end
+  #
+  # Which provides you with the full standard validation stack that you
+  # know from Active Record:
+  #
+  #   person = Person.new
+  #   person.valid?                   # => true
+  #   person.invalid?                 # => false
+  #
+  #   person.first_name = 'zoolander'
+  #   person.valid?                   # => false
+  #   person.invalid?                 # => true
+  #   person.errors.messages          # => {first_name:["starts with z."]}
+  #
+  # Note that <tt>ActiveModel::Validations</tt> automatically adds an +errors+
+  # method to your instances initialized with a new <tt>ActiveModel::Errors</tt>
+  # object, so there is no need for you to do this manually.
+  module Validations
+    extend ActiveSupport::Concern
+
+    extend ActiveModel::Naming
+
+    extend ActiveModel::Callbacks
+
+    extend ActiveModel::Translation
+
+    extend HelperMethods
+
+    include HelperMethods
+
+    attr_accessor validation_context: untyped
+
+    module ClassMethods
+      # Validates each attribute against a block.
+      #
+      #   class Person
+      #     include ActiveModel::Validations
+      #
+      #     attr_accessor :first_name, :last_name
+      #
+      #     validates_each :first_name, :last_name, allow_blank: true do |record, attr, value|
+      #       record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
+      #     end
+      #   end
+      #
+      # Options:
+      # * <tt>:on</tt> - Specifies the contexts where this validation is active.
+      #   Runs in all validation contexts by default +nil+. You can pass a symbol
+      #   or an array of symbols. (e.g. <tt>on: :create</tt> or
+      #   <tt>on: :custom_validation_context</tt> or
+      #   <tt>on: [:create, :custom_validation_context]</tt>)
+      # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+.
+      # * <tt>:allow_blank</tt> - Skip validation if attribute is blank.
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
+      #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
+      #   proc or string should return or evaluate to a +true+ or +false+ value.
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+      #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
+      #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
+      #   method, proc or string should return or evaluate to a +true+ or +false+
+      #   value.
+      def validates_each: (*untyped attr_names) { () -> untyped } -> untyped
+
+      VALID_OPTIONS_FOR_VALIDATE: untyped
+
+      # Adds a validation method or block to the class. This is useful when
+      # overriding the +validate+ instance method becomes too unwieldy and
+      # you're looking for more descriptive declaration of your validations.
+      #
+      # This can be done with a symbol pointing to a method:
+      #
+      #   class Comment
+      #     include ActiveModel::Validations
+      #
+      #     validate :must_be_friends
+      #
+      #     def must_be_friends
+      #       errors.add(:base, 'Must be friends to leave a comment') unless commenter.friend_of?(commentee)
+      #     end
+      #   end
+      #
+      # With a block which is passed with the current record to be validated:
+      #
+      #   class Comment
+      #     include ActiveModel::Validations
+      #
+      #     validate do |comment|
+      #       comment.must_be_friends
+      #     end
+      #
+      #     def must_be_friends
+      #       errors.add(:base, 'Must be friends to leave a comment') unless commenter.friend_of?(commentee)
+      #     end
+      #   end
+      #
+      # Or with a block where self points to the current record to be validated:
       #
-      #   class Person
+      #   class Comment
       #     include ActiveModel::Validations
-      #     validates_with MyValidator, MyOtherValidator, on: :create
+      #
+      #     validate do
+      #       errors.add(:base, 'Must be friends to leave a comment') unless commenter.friend_of?(commentee)
+      #     end
       #   end
       #
-      # Configuration options:
+      # Note that the return value of validation methods is not relevant.
+      # It's not possible to halt the validate callback chain.
+      #
+      # Options:
       # * <tt>:on</tt> - Specifies the contexts where this validation is active.
       #   Runs in all validation contexts by default +nil+. You can pass a symbol
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
@@ -3912,71 +3814,234 @@ module ActiveModel
       #   <tt>on: [:create, :custom_validation_context]</tt>)
       # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
-      #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>).
-      #   The method, proc or string should return or evaluate to a +true+ or
-      #   +false+ value.
+      #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
+      #   proc or string should return or evaluate to a +true+ or +false+ value.
       # * <tt>:unless</tt> - Specifies a method, proc or string to call to
-      #   determine if the validation should not occur
-      #   (e.g. <tt>unless: :skip_validation</tt>, or
-      #   <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>).
-      #   The method, proc or string should return or evaluate to a +true+ or
-      #   +false+ value.
-      # * <tt>:strict</tt> - Specifies whether validation should be strict.
-      #   See <tt>ActiveModel::Validations#validates!</tt> for more information.
+      #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
+      #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
+      #   method, proc or string should return or evaluate to a +true+ or +false+
+      #   value.
       #
-      # If you pass any additional configuration options, they will be passed
-      # to the class and available as +options+:
+      # NOTE: Calling +validate+ multiple times on the same method will overwrite previous definitions.
+      #
+      def validate: (*untyped args) { () -> untyped } -> untyped
+
+      # List all validators that are being used to validate the model using
+      # +validates_with+ method.
       #
       #   class Person
       #     include ActiveModel::Validations
-      #     validates_with MyValidator, my_custom_key: 'my custom value'
+      #
+      #     validates_with MyValidator
+      #     validates_with OtherValidator, on: :create
+      #     validates_with StrictValidator, strict: true
       #   end
       #
-      #   class MyValidator < ActiveModel::Validator
-      #     def validate(record)
-      #       options[:my_custom_key] # => "my custom value"
+      #   Person.validators
+      #   # => [
+      #   #      #<MyValidator:0x007fbff403e808 @options={}>,
+      #   #      #<OtherValidator:0x007fbff403d930 @options={on: :create}>,
+      #   #      #<StrictValidator:0x007fbff3204a30 @options={strict:true}>
+      #   #    ]
+      def validators: () -> untyped
+
+      # Clears all of the validators and validations.
+      #
+      # Note that this will clear anything that is being used to validate
+      # the model for both the +validates_with+ and +validate+ methods.
+      # It clears the validators that are created with an invocation of
+      # +validates_with+ and the callbacks that are set by an invocation
+      # of +validate+.
+      #
+      #   class Person
+      #     include ActiveModel::Validations
+      #
+      #     validates_with MyValidator
+      #     validates_with OtherValidator, on: :create
+      #     validates_with StrictValidator, strict: true
+      #     validate :cannot_be_robot
+      #
+      #     def cannot_be_robot
+      #       errors.add(:base, 'A person cannot be a robot') if person_is_robot
       #     end
       #   end
-      def validates_with: (*untyped args) { () -> untyped } -> untyped
+      #
+      #   Person.validators
+      #   # => [
+      #   #      #<MyValidator:0x007fbff403e808 @options={}>,
+      #   #      #<OtherValidator:0x007fbff403d930 @options={on: :create}>,
+      #   #      #<StrictValidator:0x007fbff3204a30 @options={strict:true}>
+      #   #    ]
+      #
+      # If one runs <tt>Person.clear_validators!</tt> and then checks to see what
+      # validators this class has, you would obtain:
+      #
+      #   Person.validators # => []
+      #
+      # Also, the callback set by <tt>validate :cannot_be_robot</tt> will be erased
+      # so that:
+      #
+      #   Person._validate_callbacks.empty?  # => true
+      #
+      def clear_validators!: () -> untyped
+
+      # List all validators that are being used to validate a specific attribute.
+      #
+      #   class Person
+      #     include ActiveModel::Validations
+      #
+      #     attr_accessor :name , :age
+      #
+      #     validates_presence_of :name
+      #     validates_inclusion_of :age, in: 0..99
+      #   end
+      #
+      #   Person.validators_on(:name)
+      #   # => [
+      #   #       #<ActiveModel::Validations::PresenceValidator:0x007fe604914e60 @attributes=[:name], @options={}>,
+      #   #    ]
+      def validators_on: (*untyped attributes) -> untyped
+
+      # Returns +true+ if +attribute+ is an attribute method, +false+ otherwise.
+      #
+      #  class Person
+      #    include ActiveModel::Validations
+      #
+      #    attr_accessor :name
+      #  end
+      #
+      #  User.attribute_method?(:name) # => true
+      #  User.attribute_method?(:age)  # => false
+      def attribute_method?: (untyped attribute) -> untyped
+
+      def inherited: (untyped base) -> untyped
     end
 
-    # Passes the record off to the class or classes specified and allows them
-    # to add errors based on more complex conditions.
+    def initialize_dup: (untyped other) -> untyped
+
+    # Returns the +Errors+ object that holds all information about attribute
+    # error messages.
     #
     #   class Person
     #     include ActiveModel::Validations
     #
-    #     validate :instance_validations
+    #     attr_accessor :name
+    #     validates_presence_of :name
+    #   end
     #
-    #     def instance_validations
-    #       validates_with MyValidator
-    #     end
+    #   person = Person.new
+    #   person.valid? # => false
+    #   person.errors # => #<ActiveModel::Errors:0x007fe603816640 @messages={name:["can't be blank"]}>
+    def errors: () -> untyped
+
+    # Runs all the specified validations and returns +true+ if no errors were
+    # added otherwise +false+.
+    #
+    #   class Person
+    #     include ActiveModel::Validations
+    #
+    #     attr_accessor :name
+    #     validates_presence_of :name
     #   end
     #
-    # Please consult the class method documentation for more information on
-    # creating your own validator.
+    #   person = Person.new
+    #   person.name = ''
+    #   person.valid? # => false
+    #   person.name = 'david'
+    #   person.valid? # => true
     #
-    # You may also pass it multiple classes, like so:
+    # Context can optionally be supplied to define which callbacks to test
+    # against (the context is defined on the validations using <tt>:on</tt>).
     #
     #   class Person
     #     include ActiveModel::Validations
     #
-    #     validate :instance_validations, on: :create
+    #     attr_accessor :name
+    #     validates_presence_of :name, on: :new
+    #   end
     #
-    #     def instance_validations
-    #       validates_with MyValidator, MyOtherValidator
-    #     end
+    #   person = Person.new
+    #   person.valid?       # => true
+    #   person.valid?(:new) # => false
+    def valid?: (?untyped? context) -> untyped
+
+    alias validate valid?
+
+    # Performs the opposite of <tt>valid?</tt>. Returns +true+ if errors were
+    # added, +false+ otherwise.
+    #
+    #   class Person
+    #     include ActiveModel::Validations
+    #
+    #     attr_accessor :name
+    #     validates_presence_of :name
     #   end
     #
-    # Standard configuration options (<tt>:on</tt>, <tt>:if</tt> and
-    # <tt>:unless</tt>), which are available on the class version of
-    # +validates_with+, should instead be placed on the +validates+ method
-    # as these are applied and tested in the callback.
+    #   person = Person.new
+    #   person.name = ''
+    #   person.invalid? # => true
+    #   person.name = 'david'
+    #   person.invalid? # => false
     #
-    # If you pass any additional configuration options, they will be passed
-    # to the class and available as +options+, please refer to the
-    # class version of this method for more information.
-    def validates_with: (*untyped args) { () -> untyped } -> untyped
+    # Context can optionally be supplied to define which callbacks to test
+    # against (the context is defined on the validations using <tt>:on</tt>).
+    #
+    #   class Person
+    #     include ActiveModel::Validations
+    #
+    #     attr_accessor :name
+    #     validates_presence_of :name, on: :new
+    #   end
+    #
+    #   person = Person.new
+    #   person.invalid?       # => false
+    #   person.invalid?(:new) # => true
+    def invalid?: (?untyped? context) -> untyped
+
+    # Runs all the validations within the specified context. Returns +true+ if
+    # no errors are found, raises +ValidationError+ otherwise.
+    #
+    # Validations with no <tt>:on</tt> option will run no matter the context. Validations with
+    # some <tt>:on</tt> option will only run in the specified context.
+    def validate!: (?untyped? context) -> untyped
+
+    # Hook method defining how an attribute value should be retrieved. By default
+    # this is assumed to be an instance named after the attribute. Override this
+    # method in subclasses should you need to retrieve the value for a given
+    # attribute differently:
+    #
+    #   class MyClass
+    #     include ActiveModel::Validations
+    #
+    #     def initialize(data = {})
+    #       @data = data
+    #     end
+    #
+    #     def read_attribute_for_validation(key)
+    #       @data[key]
+    #     end
+    #   end
+    alias read_attribute_for_validation send
+
+    def run_validations!: () -> untyped
+
+    def raise_validation_error: () -> untyped
+  end
+
+  # = Active Model ValidationError
+  #
+  # Raised by <tt>validate!</tt> when the model is invalid. Use the
+  # +model+ method to retrieve the record which did not validate.
+  #
+  #   begin
+  #     complex_operation_that_internally_calls_validate!
+  #   rescue ActiveModel::ValidationError => invalid
+  #     puts invalid.model.errors
+  #   end
+  class ValidationError < StandardError
+    attr_reader model: untyped
+
+    def initialize: (untyped model) -> untyped
   end
 end
 
@@ -4137,3 +4202,13 @@ module ActiveModel
   # Returns the version of the currently loaded \Active \Model as a <tt>Gem::Version</tt>
   def self.version: () -> untyped
 end
+
+module ActiveModel
+  extend ActiveSupport::Autoload
+
+  module Serializers
+    extend ActiveSupport::Autoload
+  end
+
+  def self.eager_load!: () -> untyped
+end