rbs_rails 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9b730da55f64b177f506e6f29efa54bba6878e3cd36b49df76703ac749feb1a
-  data.tar.gz: c759ea33ab9071df4806b81f14b5ca125b2f2df04054c4f3a9d2eb6e305c92ab
+  metadata.gz: 8cc75e64602e5966e87f1bfe2b9530034f81999715b5d9e3697f4f424af9a6da
+  data.tar.gz: 5d742b05e28d190c940d44585883be713133095d17d5778c6e64fbf2ef3b3719
 SHA512:
-  metadata.gz: 7a8fbf409f920b17353906c93d0f86d3c94b270801ab184e2e92b47ceb050659dfaa163cd3d0204e54e970db325826ddb7c6a6df5e380f8342bae760c7d0025c
-  data.tar.gz: 06a2387300377054f6ccc1cd9a5414cb64753adfb9ef5e109f95234ec50e8cc5a83b148aa46cc9140cfd47705eb9275c7ca762824564993a6226a77351f33102
+  metadata.gz: 5b07cb43cba9d2bf51beddbfdb45ad4c2e29bc6c80d6301259af7b289c8ab832b2908bbb4d96594cf7ca7d9318c54481c11daf07d6d20dc3826518b40f5b5144
+  data.tar.gz: 2af365f0d0c891d677bd60f4322566aec9897edd93585dfc6871f5ad5923985f9fe8503520b884f98382c5954ca5ab2ce1ec35ed674727449305f35ca1260c02

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+
+rvm:
+  - 2.6.5
+  - 2.7.0
+  - ruby-head
+
+cache: bundler

data/Gemfile

@@ -4,3 +4,5 @@ source "https://rubygems.org"
 gemspec
 
 gem "rake", "~> 12.0"
+gem 'rbs', '>= 0.4.0'
+gem 'steep'

data/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -1,8 +1,6 @@
-# RbsRails
+# RBS Rails
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/rbs_rails`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+RBS files generator for Ruby on Rails.
 
 ## Installation
 
@@ -22,7 +20,56 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### For Active Record models
+
+It has two tasks.
+
+* `copy_signature_files`: Copy type definition files for Rails from rbs_rails.
+* `generate_rbs_for_model`: Generate RBS files from model classes.
+
+```ruby
+# Rakefile
+
+task copy_signature_files: :environment do
+  require 'rbs_rails'
+
+  to = Rails.root.join('sig/rbs_rails/')
+  to.mkpath unless to.exist?
+  RbsRails.copy_signatures(to: to)
+end
+
+task generate_rbs_for_model: :environment do
+  require 'rbs_rails'
+
+  out_dir = Rails.root / 'sig'
+  out_dir.mkdir unless out_dir.exist?
+
+  Rails.application.eager_load!
+
+  ActiveRecord::Base.descendants.each do |klass|
+    next if klass.abstract_class?
+
+    path = out_dir / "app/models/#{klass.name.underscore}.rbs"
+    FileUtils.mkdir_p(path.dirname)
+
+    sig = RbsRails::ActiveRecord.class_to_rbs(klass, mode: :extension)
+    path.write sig
+  end
+end
+```
+
+### For path helpers
+
+```ruby
+# Rakefile
+
+task generate_rbs_for_path_helpers: :environment do
+  require 'rbs_rails'
+  out_path = Rails.root.join 'sig/path_helpers.rbs'
+  rbs = RbsRails::PathHelpers.generate
+  out_path.write rbs
+end
+```
 
 ## Development
 

data/Rakefile

@@ -1,2 +1,7 @@
 require "bundler/gem_tasks"
-task :default => :spec
+task :default => :steep
+
+desc 'run Steep'
+task :steep do
+  sh 'steep', 'check'
+end

data/Steepfile

@@ -0,0 +1,9 @@
+target :lib do
+  signature "sig"
+  signature 'assets/sig'
+
+  check "lib"                       # Directory name
+
+  library "pathname"
+  # library "strong_json"           # Gems
+end

data/assets/sig/action_controller.rbs

@@ -0,0 +1,44 @@
+interface _ActionController_API_and_Base
+  def request: () -> untyped
+  def params: () -> untyped
+  def session: () -> untyped
+  def cookies: () -> untyped
+  def flash: () -> untyped
+  def render: (*untyped) -> void
+  def redirect_to: (*untyped) -> void
+end
+
+interface _ActionController_API_and_Base_singletion
+  # hooks
+  def before_action: (*untyped) -> void
+  def around_action: (*untyped) -> void
+  def after_action: (*untyped) -> void
+  def skip_before_action: (*untyped) -> void
+  def skip_around_action: (*untyped) -> void
+  def skip_after_action: (*untyped) -> void
+  def prepend_before_action: (*untyped) -> void
+  def prepend_around_action: (*untyped) -> void
+  def prepend_after_action: (*untyped) -> void
+  def append_before_action: (*untyped) -> void
+  def append_around_action: (*untyped) -> void
+  def append_after_action: (*untyped) -> void
+
+  def rescue_from: (*Class, ?with: Symbol | Proc) { (Exception) -> void } -> void
+end
+
+class AbstractController::Base
+end
+
+class ActionController::Metal < AbstractController::Base
+end
+
+class ActionController::Base < ActionController::Metal
+  include _ActionController_API_and_Base
+  extend _ActionController_API_and_Base_singletion
+  extend ActionView::Layouts::ClassMethods
+end
+
+class ActionController::API < ActionController::Metal
+  include _ActionController_API_and_Base
+  extend _ActionController_API_and_Base_singletion
+end

data/assets/sig/action_mailer.rbs

@@ -0,0 +1,5 @@
+class ActionMailer::Base
+  extend ActionView::Layouts::ClassMethods
+
+  def self.default: (?Hash[Symbol, untyped] value) -> Hash[Symbol, untyped]
+end

data/assets/sig/action_view.rbs

@@ -0,0 +1,3 @@
+module ActionView::Layouts::ClassMethods
+  def layout: (String) -> void
+end

data/assets/sig/active_record.rbs

@@ -1,4 +1,5 @@
 class ActiveRecord::Base
+  def self.abstract_class=: (bool) -> void
   def self.scope: (Symbol, ^(*untyped) -> untyped ) -> void
                 | (Symbol) { (*untyped) -> untyped } -> void
   def self.belongs_to: (Symbol, ?untyped, **untyped) -> void
@@ -28,6 +29,9 @@ class ActiveRecord::Base
   def self.before_update: (*untyped) -> void
   def self.before_validation: (*untyped) -> void
 
+  def self.columns: () -> Array[untyped]
+  def self.reflect_on_all_associations: (?Symbol) -> Array[untyped]
+
   def will_save_change_to_attribute?: (String | Symbol attr_name, ?from: untyped, ?to: untyped) -> bool
 
   def save!: () -> self

data/assets/sig/builtin.rbs

@@ -0,0 +1,7 @@
+class Monitor
+end
+class MonitorMixin
+end
+
+module Singleton
+end

data/assets/sig/generated/activemodel.rbs

@@ -0,0 +1,3877 @@
+module ActiveModel
+  # Returns the version of the currently loaded \Active \Model as a <tt>Gem::Version</tt>
+  def self.gem_version: () -> untyped
+
+  extend ActiveSupport::Autoload
+
+  def self.eager_load!: () -> untyped
+
+  # Returns the version of the currently loaded \Active \Model as a <tt>Gem::Version</tt>
+  def self.version: () -> untyped
+end
+
+module ActiveModel::AttributeAssignment
+  include ActiveModel::ForbiddenAttributesProtection
+
+  # Allows you to set all the attributes by passing in a hash of attributes with
+  # keys matching the attribute names.
+  #
+  # If the passed hash responds to <tt>permitted?</tt> method and the return value
+  # of this method is +false+ an <tt>ActiveModel::ForbiddenAttributesError</tt>
+  # exception is raised.
+  #
+  #   class Cat
+  #     include ActiveModel::AttributeAssignment
+  #     attr_accessor :name, :status
+  #   end
+  #
+  #   cat = Cat.new
+  #   cat.assign_attributes(name: "Gorby", status: "yawning")
+  #   cat.name # => 'Gorby'
+  #   cat.status # => 'yawning'
+  #   cat.assign_attributes(status: "sleeping")
+  #   cat.name # => 'Gorby'
+  #   cat.status # => 'sleeping'
+  def assign_attributes: (untyped new_attributes) -> (nil | untyped)
+
+  def _assign_attributes: (untyped attributes) -> untyped
+
+  def _assign_attribute: (untyped k, untyped v) -> untyped
+end
+
+# Raised when an attribute is not defined.
+#
+#   class User < ActiveRecord::Base
+#     has_many :pets
+#   end
+#
+#   user = User.first
+#   user.pets.select(:id).first.user_id
+#   # => ActiveModel::MissingAttributeError: missing attribute: user_id
+class ActiveModel::MissingAttributeError[T] < NoMethodError[T]
+end
+
+# == Active \Model \Attribute \Methods
+#
+# Provides a way to add prefixes and suffixes to your methods as
+# well as handling the creation of <tt>ActiveRecord::Base</tt>-like
+# class methods such as +table_name+.
+#
+# The requirements to implement <tt>ActiveModel::AttributeMethods</tt> are to:
+#
+# * <tt>include ActiveModel::AttributeMethods</tt> in your class.
+# * Call each of its methods you want to add, such as +attribute_method_suffix+
+#   or +attribute_method_prefix+.
+# * Call +define_attribute_methods+ after the other methods are called.
+# * Define the various generic +_attribute+ methods that you have declared.
+# * Define an +attributes+ method which returns a hash with each
+#   attribute name in your model as hash key and the attribute value as hash value.
+#   Hash keys must be strings.
+#
+# A minimal implementation could be:
+#
+#   class Person
+#     include ActiveModel::AttributeMethods
+#
+#     attribute_method_affix  prefix: 'reset_', suffix: '_to_default!'
+#     attribute_method_suffix '_contrived?'
+#     attribute_method_prefix 'clear_'
+#     define_attribute_methods :name
+#
+#     attr_accessor :name
+#
+#     def attributes
+#       { 'name' => @name }
+#     end
+#
+#     private
+#
+#     def attribute_contrived?(attr)
+#       true
+#     end
+#
+#     def clear_attribute(attr)
+#       send("#{attr}=", nil)
+#     end
+#
+#     def reset_attribute_to_default!(attr)
+#       send("#{attr}=", 'Default Name')
+#     end
+#   end
+module ActiveModel::AttributeMethods
+  extend ActiveSupport::Concern
+
+  # Allows access to the object attributes, which are held in the hash
+  # returned by <tt>attributes</tt>, as though they were first-class
+  # methods. So a +Person+ class with a +name+ attribute can for example use
+  # <tt>Person#name</tt> and <tt>Person#name=</tt> and never directly use
+  # the attributes hash -- except for multiple assignments with
+  # <tt>ActiveRecord::Base#attributes=</tt>.
+  #
+  # It's also possible to instantiate related objects, so a <tt>Client</tt>
+  # class belonging to the +clients+ table with a +master_id+ foreign key
+  # can instantiate master through <tt>Client#master</tt>.
+  def method_missing: (untyped method, *untyped args) { () -> untyped } -> untyped
+
+  # +attribute_missing+ is like +method_missing+, but for attributes. When
+  # +method_missing+ is called we check to see if there is a matching
+  # attribute method. If so, we tell +attribute_missing+ to dispatch the
+  # attribute. This method can be overloaded to customize the behavior.
+  def attribute_missing: (untyped match, *untyped args) { () -> untyped } -> untyped
+
+  def respond_to?: (untyped method, ?bool include_private_methods) -> untyped
+
+  def attribute_method?: (untyped attr_name) -> untyped
+
+  # Returns a struct representing the matching attribute method.
+  # The struct's attributes are prefix, base and suffix.
+  def matched_attribute_method: (untyped method_name) -> untyped
+
+  def missing_attribute: (untyped attr_name, untyped stack) -> untyped
+
+  def _read_attribute: (untyped attr) -> untyped
+end
+
+ActiveModel::AttributeMethods::NAME_COMPILABLE_REGEXP: untyped
+
+ActiveModel::AttributeMethods::CALL_COMPILABLE_REGEXP: untyped
+
+module ActiveModel::AttributeMethods::ClassMethods
+  # Declares a method available for all attributes with the given prefix.
+  # Uses +method_missing+ and <tt>respond_to?</tt> to rewrite the method.
+  #
+  #   #{prefix}#{attr}(*args, &block)
+  #
+  # to
+  #
+  #   #{prefix}attribute(#{attr}, *args, &block)
+  #
+  # An instance method <tt>#{prefix}attribute</tt> must exist and accept
+  # at least the +attr+ argument.
+  #
+  #   class Person
+  #     include ActiveModel::AttributeMethods
+  #
+  #     attr_accessor :name
+  #     attribute_method_prefix 'clear_'
+  #     define_attribute_methods :name
+  #
+  #     private
+  #
+  #     def clear_attribute(attr)
+  #       send("#{attr}=", nil)
+  #     end
+  #   end
+  #
+  #   person = Person.new
+  #   person.name = 'Bob'
+  #   person.name          # => "Bob"
+  #   person.clear_name
+  #   person.name          # => nil
+  def attribute_method_prefix: (*untyped prefixes) -> untyped
+
+  # Declares a method available for all attributes with the given suffix.
+  # Uses +method_missing+ and <tt>respond_to?</tt> to rewrite the method.
+  #
+  #   #{attr}#{suffix}(*args, &block)
+  #
+  # to
+  #
+  #   attribute#{suffix}(#{attr}, *args, &block)
+  #
+  # An <tt>attribute#{suffix}</tt> instance method must exist and accept at
+  # least the +attr+ argument.
+  #
+  #   class Person
+  #     include ActiveModel::AttributeMethods
+  #
+  #     attr_accessor :name
+  #     attribute_method_suffix '_short?'
+  #     define_attribute_methods :name
+  #
+  #     private
+  #
+  #     def attribute_short?(attr)
+  #       send(attr).length < 5
+  #     end
+  #   end
+  #
+  #   person = Person.new
+  #   person.name = 'Bob'
+  #   person.name          # => "Bob"
+  #   person.name_short?   # => true
+  def attribute_method_suffix: (*untyped suffixes) -> untyped
+
+  # Declares a method available for all attributes with the given prefix
+  # and suffix. Uses +method_missing+ and <tt>respond_to?</tt> to rewrite
+  # the method.
+  #
+  #   #{prefix}#{attr}#{suffix}(*args, &block)
+  #
+  # to
+  #
+  #   #{prefix}attribute#{suffix}(#{attr}, *args, &block)
+  #
+  # An <tt>#{prefix}attribute#{suffix}</tt> instance method must exist and
+  # accept at least the +attr+ argument.
+  #
+  #   class Person
+  #     include ActiveModel::AttributeMethods
+  #
+  #     attr_accessor :name
+  #     attribute_method_affix prefix: 'reset_', suffix: '_to_default!'
+  #     define_attribute_methods :name
+  #
+  #     private
+  #
+  #     def reset_attribute_to_default!(attr)
+  #       send("#{attr}=", 'Default Name')
+  #     end
+  #   end
+  #
+  #   person = Person.new
+  #   person.name                         # => 'Gem'
+  #   person.reset_name_to_default!
+  #   person.name                         # => 'Default Name'
+  def attribute_method_affix: (*untyped affixes) -> untyped
+
+  # Allows you to make aliases for attributes.
+  #
+  #   class Person
+  #     include ActiveModel::AttributeMethods
+  #
+  #     attr_accessor :name
+  #     attribute_method_suffix '_short?'
+  #     define_attribute_methods :name
+  #
+  #     alias_attribute :nickname, :name
+  #
+  #     private
+  #
+  #     def attribute_short?(attr)
+  #       send(attr).length < 5
+  #     end
+  #   end
+  #
+  #   person = Person.new
+  #   person.name = 'Bob'
+  #   person.name            # => "Bob"
+  #   person.nickname        # => "Bob"
+  #   person.name_short?     # => true
+  #   person.nickname_short? # => true
+  def alias_attribute: (untyped new_name, untyped old_name) -> untyped
+
+  # Is +new_name+ an alias?
+  def attribute_alias?: (untyped new_name) -> untyped
+
+  # Returns the original name for the alias +name+
+  def attribute_alias: (untyped name) -> untyped
+
+  # Declares the attributes that should be prefixed and suffixed by
+  # <tt>ActiveModel::AttributeMethods</tt>.
+  #
+  # To use, pass attribute names (as strings or symbols). Be sure to declare
+  # +define_attribute_methods+ after you define any prefix, suffix or affix
+  # methods, or they will not hook in.
+  #
+  #   class Person
+  #     include ActiveModel::AttributeMethods
+  #
+  #     attr_accessor :name, :age, :address
+  #     attribute_method_prefix 'clear_'
+  #
+  #     # Call to define_attribute_methods must appear after the
+  #     # attribute_method_prefix, attribute_method_suffix or
+  #     # attribute_method_affix declarations.
+  #     define_attribute_methods :name, :age, :address
+  #
+  #     private
+  #
+  #     def clear_attribute(attr)
+  #       send("#{attr}=", nil)
+  #     end
+  #   end
+  def define_attribute_methods: (*untyped attr_names) -> untyped
+
+  # Declares an attribute that should be prefixed and suffixed by
+  # <tt>ActiveModel::AttributeMethods</tt>.
+  #
+  # To use, pass an attribute name (as string or symbol). Be sure to declare
+  # +define_attribute_method+ after you define any prefix, suffix or affix
+  # method, or they will not hook in.
+  #
+  #   class Person
+  #     include ActiveModel::AttributeMethods
+  #
+  #     attr_accessor :name
+  #     attribute_method_suffix '_short?'
+  #
+  #     # Call to define_attribute_method must appear after the
+  #     # attribute_method_prefix, attribute_method_suffix or
+  #     # attribute_method_affix declarations.
+  #     define_attribute_method :name
+  #
+  #     private
+  #
+  #     def attribute_short?(attr)
+  #       send(attr).length < 5
+  #     end
+  #   end
+  #
+  #   person = Person.new
+  #   person.name = 'Bob'
+  #   person.name        # => "Bob"
+  #   person.name_short? # => true
+  def define_attribute_method: (untyped attr_name) -> untyped
+
+  # Removes all the previously dynamically defined methods from the class.
+  #
+  #   class Person
+  #     include ActiveModel::AttributeMethods
+  #
+  #     attr_accessor :name
+  #     attribute_method_suffix '_short?'
+  #     define_attribute_method :name
+  #
+  #     private
+  #
+  #     def attribute_short?(attr)
+  #       send(attr).length < 5
+  #     end
+  #   end
+  #
+  #   person = Person.new
+  #   person.name = 'Bob'
+  #   person.name_short? # => true
+  #
+  #   Person.undefine_attribute_methods
+  #
+  #   person.name_short? # => NoMethodError
+  def undefine_attribute_methods: () -> untyped
+
+  def generated_attribute_methods: () -> untyped
+
+  def instance_method_already_implemented?: (untyped method_name) -> untyped
+
+  # The methods +method_missing+ and +respond_to?+ of this module are
+  # invoked often in a typical rails, both of which invoke the method
+  # +matched_attribute_method+. The latter method iterates through an
+  # array doing regular expression matches, which results in a lot of
+  # object creations. Most of the time it returns a +nil+ match. As the
+  # match result is always the same given a +method_name+, this cache is
+  # used to alleviate the GC, which ultimately also speeds up the app
+  # significantly (in our case our test suite finishes 10% faster with
+  # this cache).
+  def attribute_method_matchers_cache: () -> untyped
+
+  def attribute_method_matchers_matching: (untyped method_name) -> untyped
+
+  # Define a method `name` in `mod` that dispatches to `send`
+  # using the given `extra` args. This falls back on `define_method`
+  # and `send` if the given names cannot be compiled.
+  def define_proxy_call: (untyped include_private, untyped mod, untyped name, untyped target, *untyped extra) -> untyped
+end
+
+class ActiveModel::AttributeMethods::ClassMethods::AttributeMethodMatcher
+  # nodoc:
+  attr_reader prefix: untyped
+
+  # nodoc:
+  attr_reader suffix: untyped
+
+  # nodoc:
+  attr_reader target: untyped
+
+  def initialize: (?::Hash[untyped, untyped] options) -> untyped
+
+  def match: (untyped method_name) -> untyped
+
+  def method_name: (untyped attr_name) -> untyped
+
+  def plain?: () -> untyped
+end
+
+ActiveModel::AttributeMethods::ClassMethods::AttributeMethodMatcher::AttributeMethodMatch: untyped
+
+module ActiveModel::AttributeMethods::AttrNames
+  # We want to generate the methods via module_eval rather than
+  # define_method, because define_method is slower on dispatch.
+  # Evaluating many similar methods may use more memory as the instruction
+  # sequences are duplicated and cached (in MRI).  define_method may
+  # be slower on dispatch, but if you're careful about the closure
+  # created, then define_method will consume much less memory.
+  #
+  # But sometimes the database might return columns with
+  # characters that are not allowed in normal method names (like
+  # 'my_column(omg)'. So to work around this we first define with
+  # the __temp__ identifier, and then use alias method to rename
+  # it to what we want.
+  #
+  # We are also defining a constant to hold the frozen string of
+  # the attribute name. Using a constant means that we do not have
+  # to allocate an object on each call to the attribute method.
+  # Making it frozen means that it doesn't get duped when used to
+  # key the @attributes in read_attribute.
+  def self.define_attribute_accessor_method: (untyped mod, untyped attr_name, ?writer: bool writer) { (untyped, untyped) -> untyped } -> untyped
+end
+
+# :nodoc:
+ActiveModel::AttributeMethods::AttrNames::DEF_SAFE_NAME: untyped
+
+class ActiveModel::AttributeMutationTracker
+  def initialize: (untyped attributes, ?untyped forced_changes) -> untyped
+
+  def changed_attribute_names: () -> untyped
+
+  def changed_values: () -> untyped
+
+  def changes: () -> untyped
+
+  def change_to_attribute: (untyped attr_name) -> untyped
+
+  def any_changes?: () -> untyped
+
+  def changed?: (untyped attr_name, ?to: untyped to, ?from: untyped from) -> untyped
+
+  def changed_in_place?: (untyped attr_name) -> untyped
+
+  def forget_change: (untyped attr_name) -> untyped
+
+  def original_value: (untyped attr_name) -> untyped
+
+  def force_change: (untyped attr_name) -> untyped
+
+  attr_reader attributes: untyped
+
+  attr_reader forced_changes: untyped
+
+  def attr_names: () -> untyped
+
+  def attribute_changed?: (untyped attr_name) -> untyped
+
+  def fetch_value: (untyped attr_name) -> untyped
+end
+
+# :nodoc:
+ActiveModel::AttributeMutationTracker::OPTION_NOT_GIVEN: untyped
+
+class ActiveModel::ForcedMutationTracker < AttributeMutationTracker
+  # :nodoc:
+  def initialize: (untyped attributes, ?::Hash[untyped, untyped] forced_changes) -> untyped
+
+  def changed_in_place?: (untyped attr_name) -> ::FalseClass
+
+  def change_to_attribute: (untyped attr_name) -> untyped
+
+  def forget_change: (untyped attr_name) -> untyped
+
+  def original_value: (untyped attr_name) -> untyped
+
+  def force_change: (untyped attr_name) -> untyped
+
+  def finalize_changes: () -> untyped
+
+  attr_reader finalized_changes: untyped
+
+  def attr_names: () -> untyped
+
+  def attribute_changed?: (untyped attr_name) -> untyped
+
+  def fetch_value: (untyped attr_name) -> untyped
+
+  def clone_value: (untyped attr_name) -> untyped
+end
+
+class ActiveModel::NullMutationTracker
+  # :nodoc:
+  include Singleton
+
+  def changed_attribute_names: () -> ::Array[untyped]
+
+  def changed_values: () -> ::Hash[untyped, untyped]
+
+  def changes: () -> ::Hash[untyped, untyped]
+
+  def change_to_attribute: (untyped attr_name) -> nil
+
+  def any_changes?: () -> ::FalseClass
+
+  def changed?: (untyped attr_name) -> ::FalseClass
+
+  def changed_in_place?: (untyped attr_name) -> ::FalseClass
+
+  def original_value: (untyped attr_name) -> nil
+end
+
+class ActiveModel::Attribute
+  def self.from_database: (untyped name, untyped value, untyped `type`) -> untyped
+
+  def self.from_user: (untyped name, untyped value, untyped `type`, ?untyped? original_attribute) -> untyped
+
+  def self.with_cast_value: (untyped name, untyped value, untyped `type`) -> untyped
+
+  def self.null: (untyped name) -> untyped
+
+  def self.uninitialized: (untyped name, untyped `type`) -> untyped
+
+  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
+
+  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
+
+  def initialize_dup: (untyped other) -> untyped
+
+  def changed_from_assignment?: () -> untyped
+
+  def _original_value_for_database: () -> untyped
+end
+
+class ActiveModel::Attribute::FromDatabase < Attribute
+  # :nodoc:
+  def type_cast: (untyped value) -> untyped
+
+  def _original_value_for_database: () -> untyped
+end
+
+class ActiveModel::Attribute::FromUser < Attribute
+  # :nodoc:
+  def type_cast: (untyped value) -> untyped
+
+  def came_from_user?: () -> untyped
+end
+
+class ActiveModel::Attribute::WithCastValue < Attribute
+  # :nodoc:
+  def type_cast: (untyped value) -> untyped
+
+  def changed_in_place?: () -> ::FalseClass
+end
+
+class ActiveModel::Attribute::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 ActiveModel::Attribute::Uninitialized < Attribute
+  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
+
+# :nodoc:
+ActiveModel::Attribute::Uninitialized::UNINITIALIZED_ORIGINAL_VALUE: untyped
+
+class ActiveModel::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 deep_dup: () -> untyped
+
+  def initialize_dup: (untyped _) -> untyped
+
+  def initialize_clone: (untyped _) -> untyped
+
+  def reset: (untyped key) -> untyped
+
+  def accessed: () -> untyped
+
+  def map: () { () -> untyped } -> untyped
+
+  def ==: (untyped other) -> untyped
+
+  attr_reader attributes: untyped
+
+  def initialized_attributes: () -> untyped
+end
+
+class ActiveModel::AttributeSet::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) -> untyped
+end
+
+class ActiveModel::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
+
+class ActiveModel::AttributeSet::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
+
+module ActiveModel::Attributes
+  # nodoc:
+  extend ActiveSupport::Concern
+
+  include ActiveModel::AttributeMethods
+
+  def initialize: () -> untyped
+
+  # Returns a hash of all the attributes with their names as keys and the values of the attributes as values.
+  #
+  #   class Person
+  #     include ActiveModel::Model
+  #     include ActiveModel::Attributes
+  #
+  #     attribute :name, :string
+  #     attribute :age, :integer
+  #   end
+  #
+  #   person = Person.new(name: 'Francesco', age: 22)
+  #   person.attributes
+  #   # => {"name"=>"Francesco", "age"=>22}
+  def attributes: () -> untyped
+
+  # Returns an array of attribute names as strings
+  #
+  #   class Person
+  #     include ActiveModel::Attributes
+  #
+  #     attribute :name, :string
+  #     attribute :age, :integer
+  #   end
+  #
+  #   person = Person.new
+  #   person.attribute_names
+  #   # => ["name", "age"]
+  def attribute_names: () -> untyped
+
+  def write_attribute: (untyped attr_name, untyped value) -> untyped
+
+  def attribute: (untyped attr_name) -> untyped
+
+  # Dispatch target for <tt>*=</tt> attribute methods.
+  def attribute=: (untyped attribute_name, untyped value) -> untyped
+end
+
+module ActiveModel::Attributes::ClassMethods
+  def attribute: (untyped name, ?untyped `type`, **untyped options) -> untyped
+
+  # Returns an array of attribute names as strings
+  #
+  #   class Person
+  #     include ActiveModel::Attributes
+  #
+  #     attribute :name, :string
+  #     attribute :age, :integer
+  #   end
+  #
+  #   Person.attribute_names
+  #   # => ["name", "age"]
+  def attribute_names: () -> untyped
+
+  def define_method_attribute=: (untyped name) -> untyped
+
+  def define_default_attribute: (untyped name, untyped value, untyped `type`) -> untyped
+end
+
+ActiveModel::Attributes::ClassMethods::NO_DEFAULT_PROVIDED: untyped
+
+class ActiveModel::Attribute::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
+
+# == Active \Model \Callbacks
+#
+# Provides an interface for any class to have Active Record like callbacks.
+#
+# Like the Active Record methods, the callback chain is aborted as soon as
+# one of the methods throws +:abort+.
+#
+# First, extend ActiveModel::Callbacks from the class you are creating:
+#
+#   class MyModel
+#     extend ActiveModel::Callbacks
+#   end
+#
+# Then define a list of methods that you want callbacks attached to:
+#
+#   define_model_callbacks :create, :update
+#
+# This will provide all three standard callbacks (before, around and after)
+# for both the <tt>:create</tt> and <tt>:update</tt> methods. To implement,
+# you need to wrap the methods you want callbacks on in a block so that the
+# callbacks get a chance to fire:
+#
+#   def create
+#     run_callbacks :create do
+#       # Your create action methods here
+#     end
+#   end
+#
+# Then in your class, you can use the +before_create+, +after_create+ and
+# +around_create+ methods, just as you would in an Active Record model.
+#
+#   before_create :action_before_create
+#
+#   def action_before_create
+#     # Your code here
+#   end
+#
+# When defining an around callback remember to yield to the block, otherwise
+# it won't be executed:
+#
+#  around_create :log_status
+#
+#  def log_status
+#    puts 'going to call the block...'
+#    yield
+#    puts 'block successfully called.'
+#  end
+#
+# You can choose to have only specific callbacks by passing a hash to the
+# +define_model_callbacks+ method.
+#
+#   define_model_callbacks :create, only: [:after, :before]
+#
+# Would only create the +after_create+ and +before_create+ callback methods in
+# your class.
+#
+# NOTE: Calling the same callback multiple times will overwrite previous callback definitions.
+#
+module ActiveModel::Callbacks
+  def self.extended: (untyped base) -> untyped
+
+  # define_model_callbacks accepts the same options +define_callbacks+ does,
+  # in case you want to overwrite a default. Besides that, it also accepts an
+  # <tt>:only</tt> option, where you can choose if you want all types (before,
+  # around or after) or just some.
+  #
+  #   define_model_callbacks :initializer, only: :after
+  #
+  # Note, the <tt>only: <type></tt> hash will apply to all callbacks defined
+  # on that method call. To get around this you can call the define_model_callbacks
+  # method as many times as you need.
+  #
+  #   define_model_callbacks :create,  only: :after
+  #   define_model_callbacks :update,  only: :before
+  #   define_model_callbacks :destroy, only: :around
+  #
+  # Would create +after_create+, +before_update+ and +around_destroy+ methods
+  # only.
+  #
+  # You can pass in a class to before_<type>, after_<type> and around_<type>,
+  # in which case the callback will call that class's <action>_<type> method
+  # passing the object that the callback is being called on.
+  #
+  #   class MyModel
+  #     extend ActiveModel::Callbacks
+  #     define_model_callbacks :create
+  #
+  #     before_create AnotherClass
+  #   end
+  #
+  #   class AnotherClass
+  #     def self.before_create( obj )
+  #       # obj is the MyModel instance that the callback is being called on
+  #     end
+  #   end
+  #
+  # NOTE: +method_name+ passed to define_model_callbacks must not end with
+  # <tt>!</tt>, <tt>?</tt> or <tt>=</tt>.
+  def define_model_callbacks: (*untyped callbacks) -> untyped
+
+  def _define_before_model_callback: (untyped klass, untyped callback) -> untyped
+
+  def _define_around_model_callback: (untyped klass, untyped callback) -> untyped
+
+  def _define_after_model_callback: (untyped klass, untyped callback) -> untyped
+end
+
+# == Active \Model \Conversion
+#
+# Handles default conversions: to_model, to_key, to_param, and to_partial_path.
+#
+# Let's take for example this non-persisted object.
+#
+#   class ContactMessage
+#     include ActiveModel::Conversion
+#
+#     # ContactMessage are never persisted in the DB
+#     def persisted?
+#       false
+#     end
+#   end
+#
+#   cm = ContactMessage.new
+#   cm.to_model == cm  # => true
+#   cm.to_key          # => nil
+#   cm.to_param        # => nil
+#   cm.to_partial_path # => "contact_messages/contact_message"
+module ActiveModel::Conversion
+  extend ActiveSupport::Concern
+
+  # If your object is already designed to implement all of the \Active \Model
+  # you can use the default <tt>:to_model</tt> implementation, which simply
+  # returns +self+.
+  #
+  #   class Person
+  #     include ActiveModel::Conversion
+  #   end
+  #
+  #   person = Person.new
+  #   person.to_model == person # => true
+  #
+  # If your model does not act like an \Active \Model object, then you should
+  # define <tt>:to_model</tt> yourself returning a proxy object that wraps
+  # your object with \Active \Model compliant methods.
+  def to_model: () -> untyped
+
+  # Returns an Array of all key attributes if any of the attributes is set, whether or not
+  # the object is persisted. Returns +nil+ if there are no key attributes.
+  #
+  #   class Person
+  #     include ActiveModel::Conversion
+  #     attr_accessor :id
+  #
+  #     def initialize(id)
+  #       @id = id
+  #     end
+  #   end
+  #
+  #   person = Person.new(1)
+  #   person.to_key # => [1]
+  def to_key: () -> untyped
+
+  # Returns a +string+ representing the object's key suitable for use in URLs,
+  # or +nil+ if <tt>persisted?</tt> is +false+.
+  #
+  #   class Person
+  #     include ActiveModel::Conversion
+  #     attr_accessor :id
+  #
+  #     def initialize(id)
+  #       @id = id
+  #     end
+  #
+  #     def persisted?
+  #       true
+  #     end
+  #   end
+  #
+  #   person = Person.new(1)
+  #   person.to_param # => "1"
+  def to_param: () -> untyped
+
+  # Returns a +string+ identifying the path associated with the object.
+  # ActionPack uses this to find a suitable partial to represent the object.
+  #
+  #   class Person
+  #     include ActiveModel::Conversion
+  #   end
+  #
+  #   person = Person.new
+  #   person.to_partial_path # => "people/person"
+  def to_partial_path: () -> untyped
+end
+
+module ActiveModel::Conversion::ClassMethods
+  def _to_partial_path: () -> untyped
+end
+
+# == Active \Model \Dirty
+#
+# Provides a way to track changes in your object in the same way as
+# Active Record does.
+#
+# The requirements for implementing ActiveModel::Dirty are:
+#
+# * <tt>include ActiveModel::Dirty</tt> in your object.
+# * Call <tt>define_attribute_methods</tt> passing each method you want to
+#   track.
+# * Call <tt>[attr_name]_will_change!</tt> before each change to the tracked
+#   attribute.
+# * Call <tt>changes_applied</tt> after the changes are persisted.
+# * Call <tt>clear_changes_information</tt> when you want to reset the changes
+#   information.
+# * Call <tt>restore_attributes</tt> when you want to restore previous data.
+#
+# A minimal implementation could be:
+#
+#   class Person
+#     include ActiveModel::Dirty
+#
+#     define_attribute_methods :name
+#
+#     def initialize
+#       @name = nil
+#     end
+#
+#     def name
+#       @name
+#     end
+#
+#     def name=(val)
+#       name_will_change! unless val == @name
+#       @name = val
+#     end
+#
+#     def save
+#       # do persistence work
+#
+#       changes_applied
+#     end
+#
+#     def reload!
+#       # get the values from the persistence layer
+#
+#       clear_changes_information
+#     end
+#
+#     def rollback!
+#       restore_attributes
+#     end
+#   end
+#
+# A newly instantiated +Person+ object is unchanged:
+#
+#   person = Person.new
+#   person.changed? # => false
+#
+# Change the name:
+#
+#   person.name = 'Bob'
+#   person.changed?       # => true
+#   person.name_changed?  # => true
+#   person.name_changed?(from: nil, to: "Bob") # => true
+#   person.name_was       # => nil
+#   person.name_change    # => [nil, "Bob"]
+#   person.name = 'Bill'
+#   person.name_change    # => [nil, "Bill"]
+#
+# Save the changes:
+#
+#   person.save
+#   person.changed?      # => false
+#   person.name_changed? # => false
+#
+# Reset the changes:
+#
+#   person.previous_changes         # => {"name" => [nil, "Bill"]}
+#   person.name_previously_changed? # => true
+#   person.name_previous_change     # => [nil, "Bill"]
+#   person.reload!
+#   person.previous_changes         # => {}
+#
+# Rollback the changes:
+#
+#   person.name = "Uncle Bob"
+#   person.rollback!
+#   person.name          # => "Bill"
+#   person.name_changed? # => false
+#
+# Assigning the same value leaves the attribute unchanged:
+#
+#   person.name = 'Bill'
+#   person.name_changed? # => false
+#   person.name_change   # => nil
+#
+# Which attributes have changed?
+#
+#   person.name = 'Bob'
+#   person.changed # => ["name"]
+#   person.changes # => {"name" => ["Bill", "Bob"]}
+#
+# If an attribute is modified in-place then make use of
+# <tt>[attribute_name]_will_change!</tt> to mark that the attribute is changing.
+# Otherwise \Active \Model can't track changes to in-place attributes. Note
+# that Active Record can detect in-place modifications automatically. You do
+# not need to call <tt>[attribute_name]_will_change!</tt> on Active Record models.
+#
+#   person.name_will_change!
+#   person.name_change # => ["Bill", "Bill"]
+#   person.name << 'y'
+#   person.name_change # => ["Bill", "Billy"]
+module ActiveModel::Dirty
+  extend ActiveSupport::Concern
+
+  include ActiveModel::AttributeMethods
+
+  def initialize_dup: (untyped other) -> untyped
+
+  # Clears dirty data and moves +changes+ to +previously_changed+ and
+  # +mutations_from_database+ to +mutations_before_last_save+ respectively.
+  def changes_applied: () -> untyped
+
+  # Returns +true+ if any of the attributes has unsaved changes, +false+ otherwise.
+  #
+  #   person.changed? # => false
+  #   person.name = 'bob'
+  #   person.changed? # => true
+  def changed?: () -> untyped
+
+  # Returns an array with the name of the attributes with unsaved changes.
+  #
+  #   person.changed # => []
+  #   person.name = 'bob'
+  #   person.changed # => ["name"]
+  def changed: () -> untyped
+
+  def attribute_changed?: (untyped attr_name, **untyped options) -> untyped
+
+  def attribute_was: (untyped attr_name) -> untyped
+
+  def attribute_previously_changed?: (untyped attr_name) -> untyped
+
+  # Restore all previous data of the provided attributes.
+  def restore_attributes: (?untyped attr_names) -> untyped
+
+  # Clears all dirty data: current changes and previous changes.
+  def clear_changes_information: () -> untyped
+
+  def clear_attribute_changes: (untyped attr_names) -> untyped
+
+  # Returns a hash of the attributes with unsaved changes indicating their original
+  # values like <tt>attr => original value</tt>.
+  #
+  #   person.name # => "bob"
+  #   person.name = 'robert'
+  #   person.changed_attributes # => {"name" => "bob"}
+  def changed_attributes: () -> untyped
+
+  # Returns a hash of changed attributes indicating their original
+  # and new values like <tt>attr => [original value, new value]</tt>.
+  #
+  #   person.changes # => {}
+  #   person.name = 'bob'
+  #   person.changes # => { "name" => ["bill", "bob"] }
+  def changes: () -> untyped
+
+  # Returns a hash of attributes that were changed before the model was saved.
+  #
+  #   person.name # => "bob"
+  #   person.name = 'robert'
+  #   person.save
+  #   person.previous_changes # => {"name" => ["bob", "robert"]}
+  def previous_changes: () -> untyped
+
+  def attribute_changed_in_place?: (untyped attr_name) -> untyped
+
+  def clear_attribute_change: (untyped attr_name) -> untyped
+
+  def mutations_from_database: () -> untyped
+
+  def forget_attribute_assignments: () -> untyped
+
+  def mutations_before_last_save: () -> untyped
+
+  # Dispatch target for <tt>*_change</tt> attribute methods.
+  def attribute_change: (untyped attr_name) -> untyped
+
+  # Dispatch target for <tt>*_previous_change</tt> attribute methods.
+  def attribute_previous_change: (untyped attr_name) -> untyped
+
+  # Dispatch target for <tt>*_will_change!</tt> attribute methods.
+  def attribute_will_change!: (untyped attr_name) -> untyped
+
+  # Dispatch target for <tt>restore_*!</tt> attribute methods.
+  def restore_attribute!: (untyped attr_name) -> untyped
+end
+
+# == Active \Model \Errors
+#
+# Provides a modified +Hash+ that you can include in your object
+# for handling error messages and interacting with Action View helpers.
+#
+# A minimal implementation could be:
+#
+#   class Person
+#     # Required dependency for ActiveModel::Errors
+#     extend ActiveModel::Naming
+#
+#     def initialize
+#       @errors = ActiveModel::Errors.new(self)
+#     end
+#
+#     attr_accessor :name
+#     attr_reader   :errors
+#
+#     def validate!
+#       errors.add(:name, :blank, message: "cannot be nil") if name.nil?
+#     end
+#
+#     # The following methods are needed to be minimally implemented
+#
+#     def read_attribute_for_validation(attr)
+#       send(attr)
+#     end
+#
+#     def self.human_attribute_name(attr, options = {})
+#       attr
+#     end
+#
+#     def self.lookup_ancestors
+#       [self]
+#     end
+#   end
+#
+# The last three methods are required in your object for +Errors+ to be
+# able to generate error messages correctly and also handle multiple
+# languages. Of course, if you extend your object with <tt>ActiveModel::Translation</tt>
+# you will not need to implement the last two. Likewise, using
+# <tt>ActiveModel::Validations</tt> will handle the validation related methods
+# for you.
+#
+# The above allows you to do:
+#
+#   person = Person.new
+#   person.validate!            # => ["cannot be nil"]
+#   person.errors.full_messages # => ["name cannot be nil"]
+#   # etc..
+class ActiveModel::Errors
+  include Enumerable[untyped, untyped]
+
+  attr_accessor i18n_customize_full_message: untyped
+
+  attr_reader messages: untyped
+
+  attr_reader details: untyped
+
+  # Pass in the instance of the object that is using the errors object.
+  #
+  #   class Person
+  #     def initialize
+  #       @errors = ActiveModel::Errors.new(self)
+  #     end
+  #   end
+  def initialize: (untyped base) -> untyped
+
+  def initialize_dup: (untyped other) -> untyped
+
+  def copy!: (untyped other) -> untyped
+
+  # Merges the errors from <tt>other</tt>.
+  #
+  # other - The ActiveModel::Errors instance.
+  #
+  # Examples
+  #
+  #   person.errors.merge!(other)
+  def merge!: (untyped other) -> untyped
+
+  # Removes all errors except the given keys. Returns a hash containing the removed errors.
+  #
+  #   person.errors.keys                  # => [:name, :age, :gender, :city]
+  #   person.errors.slice!(:age, :gender) # => { :name=>["cannot be nil"], :city=>["cannot be nil"] }
+  #   person.errors.keys                  # => [:age, :gender]
+  def slice!: (*untyped keys) -> untyped
+
+  # Clear the error messages.
+  #
+  #   person.errors.full_messages # => ["name cannot be nil"]
+  #   person.errors.clear
+  #   person.errors.full_messages # => []
+  def clear: () -> untyped
+
+  # Returns +true+ if the error messages include an error for the given key
+  # +attribute+, +false+ otherwise.
+  #
+  #   person.errors.messages        # => {:name=>["cannot be nil"]}
+  #   person.errors.include?(:name) # => true
+  #   person.errors.include?(:age)  # => false
+  def include?: (untyped attribute) -> untyped
+
+  # Delete messages for +key+. Returns the deleted messages.
+  #
+  #   person.errors[:name]        # => ["cannot be nil"]
+  #   person.errors.delete(:name) # => ["cannot be nil"]
+  #   person.errors[:name]        # => []
+  def delete: (untyped key) -> untyped
+
+  # When passed a symbol or a name of a method, returns an array of errors
+  # for the method.
+  #
+  #   person.errors[:name]  # => ["cannot be nil"]
+  #   person.errors['name'] # => ["cannot be nil"]
+  def []: (untyped attribute) -> untyped
+
+  # Iterates through each error key, value pair in the error messages hash.
+  # Yields the attribute and the error for that attribute. If the attribute
+  # has more than one error message, yields once for each error message.
+  #
+  #   person.errors.add(:name, :blank, message: "can't be blank")
+  #   person.errors.each do |attribute, error|
+  #     # Will yield :name and "can't be blank"
+  #   end
+  #
+  #   person.errors.add(:name, :not_specified, message: "must be specified")
+  #   person.errors.each do |attribute, error|
+  #     # Will yield :name and "can't be blank"
+  #     # then yield :name and "must be specified"
+  #   end
+  def each: () { (untyped, untyped) -> untyped } -> untyped
+
+  # Returns the number of error messages.
+  #
+  #   person.errors.add(:name, :blank, message: "can't be blank")
+  #   person.errors.size # => 1
+  #   person.errors.add(:name, :not_specified, message: "must be specified")
+  #   person.errors.size # => 2
+  def size: () -> untyped
+
+  # Returns all message values.
+  #
+  #   person.errors.messages # => {:name=>["cannot be nil", "must be specified"]}
+  #   person.errors.values   # => [["cannot be nil", "must be specified"]]
+  def values: () -> untyped
+
+  # Returns all message keys.
+  #
+  #   person.errors.messages # => {:name=>["cannot be nil", "must be specified"]}
+  #   person.errors.keys     # => [:name]
+  def keys: () -> untyped
+
+  # Returns +true+ if no errors are found, +false+ otherwise.
+  # If the error message is a string it can be empty.
+  #
+  #   person.errors.full_messages # => ["name cannot be nil"]
+  #   person.errors.empty?        # => false
+  def empty?: () -> untyped
+
+  # Returns an xml formatted representation of the Errors hash.
+  #
+  #   person.errors.add(:name, :blank, message: "can't be blank")
+  #   person.errors.add(:name, :not_specified, message: "must be specified")
+  #   person.errors.to_xml
+  #   # =>
+  #   #  <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+  #   #  <errors>
+  #   #    <error>name can't be blank</error>
+  #   #    <error>name must be specified</error>
+  #   #  </errors>
+  def to_xml: (?::Hash[untyped, untyped] options) -> untyped
+
+  # Returns a Hash that can be used as the JSON representation for this
+  # object. You can pass the <tt>:full_messages</tt> option. This determines
+  # if the json object should contain full messages or not (false by default).
+  #
+  #   person.errors.as_json                      # => {:name=>["cannot be nil"]}
+  #   person.errors.as_json(full_messages: true) # => {:name=>["name cannot be nil"]}
+  def as_json: (?untyped? options) -> untyped
+
+  # Returns a Hash of attributes with their error messages. If +full_messages+
+  # is +true+, it will contain full messages (see +full_message+).
+  #
+  #   person.errors.to_hash       # => {:name=>["cannot be nil"]}
+  #   person.errors.to_hash(true) # => {:name=>["name cannot be nil"]}
+  def to_hash: (?bool full_messages) -> untyped
+
+  # Adds +message+ to the error messages and used validator type to +details+ on +attribute+.
+  # More than one error can be added to the same +attribute+.
+  # If no +message+ is supplied, <tt>:invalid</tt> is assumed.
+  #
+  #   person.errors.add(:name)
+  #   # => ["is invalid"]
+  #   person.errors.add(:name, :not_implemented, message: "must be implemented")
+  #   # => ["is invalid", "must be implemented"]
+  #
+  #   person.errors.messages
+  #   # => {:name=>["is invalid", "must be implemented"]}
+  #
+  #   person.errors.details
+  #   # => {:name=>[{error: :not_implemented}, {error: :invalid}]}
+  #
+  # If +message+ is a symbol, it will be translated using the appropriate
+  # scope (see +generate_message+).
+  #
+  # If +message+ is a proc, it will be called, allowing for things like
+  # <tt>Time.now</tt> to be used within an error.
+  #
+  # If the <tt>:strict</tt> option is set to +true+, it will raise
+  # ActiveModel::StrictValidationFailed instead of adding the error.
+  # <tt>:strict</tt> option can also be set to any other exception.
+  #
+  #   person.errors.add(:name, :invalid, strict: true)
+  #   # => ActiveModel::StrictValidationFailed: Name is invalid
+  #   person.errors.add(:name, :invalid, strict: NameIsInvalid)
+  #   # => NameIsInvalid: Name is invalid
+  #
+  #   person.errors.messages # => {}
+  #
+  # +attribute+ should be set to <tt>:base</tt> if the error is not
+  # directly associated with a single attribute.
+  #
+  #   person.errors.add(:base, :name_or_email_blank,
+  #     message: "either name or email must be present")
+  #   person.errors.messages
+  #   # => {:base=>["either name or email must be present"]}
+  #   person.errors.details
+  #   # => {:base=>[{error: :name_or_email_blank}]}
+  def add: (untyped attribute, ?::Symbol message, ?::Hash[untyped, untyped] options) -> untyped
+
+  # Returns +true+ if an error on the attribute with the given message is
+  # present, or +false+ otherwise. +message+ is treated the same as for +add+.
+  #
+  #   person.errors.add :name, :blank
+  #   person.errors.added? :name, :blank           # => true
+  #   person.errors.added? :name, "can't be blank" # => true
+  #
+  # If the error message requires options, then it returns +true+ with
+  # the correct options, or +false+ with incorrect or missing options.
+  #
+  #   person.errors.add :name, :too_long, { count: 25 }
+  #   person.errors.added? :name, :too_long, count: 25                     # => true
+  #   person.errors.added? :name, "is too long (maximum is 25 characters)" # => true
+  #   person.errors.added? :name, :too_long, count: 24                     # => false
+  #   person.errors.added? :name, :too_long                                # => false
+  #   person.errors.added? :name, "is too long"                            # => false
+  def added?: (untyped attribute, ?::Symbol message, ?::Hash[untyped, untyped] options) -> untyped
+
+  # Returns +true+ if an error on the attribute with the given message is
+  # present, or +false+ otherwise. +message+ is treated the same as for +add+.
+  #
+  #   person.errors.add :age
+  #   person.errors.add :name, :too_long, { count: 25 }
+  #   person.errors.of_kind? :age                                            # => true
+  #   person.errors.of_kind? :name                                           # => false
+  #   person.errors.of_kind? :name, :too_long                                # => true
+  #   person.errors.of_kind? :name, "is too long (maximum is 25 characters)" # => true
+  #   person.errors.of_kind? :name, :not_too_long                            # => false
+  #   person.errors.of_kind? :name, "is too long"                            # => false
+  def of_kind?: (untyped attribute, ?::Symbol message) -> untyped
+
+  # Returns all the full error messages in an array.
+  #
+  #   class Person
+  #     validates_presence_of :name, :address, :email
+  #     validates_length_of :name, in: 5..30
+  #   end
+  #
+  #   person = Person.create(address: '123 First St.')
+  #   person.errors.full_messages
+  #   # => ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Email can't be blank"]
+  def full_messages: () -> untyped
+
+  # Returns all the full error messages for a given attribute in an array.
+  #
+  #   class Person
+  #     validates_presence_of :name, :email
+  #     validates_length_of :name, in: 5..30
+  #   end
+  #
+  #   person = Person.create()
+  #   person.errors.full_messages_for(:name)
+  #   # => ["Name is too short (minimum is 5 characters)", "Name can't be blank"]
+  def full_messages_for: (untyped attribute) -> untyped
+
+  # Returns a full message for a given attribute.
+  #
+  #   person.errors.full_message(:name, 'is invalid') # => "Name is invalid"
+  #
+  # The `"%{attribute} %{message}"` error format can be overridden with either
+  #
+  # * <tt>activemodel.errors.models.person/contacts/addresses.attributes.street.format</tt>
+  # * <tt>activemodel.errors.models.person/contacts/addresses.format</tt>
+  # * <tt>activemodel.errors.models.person.attributes.name.format</tt>
+  # * <tt>activemodel.errors.models.person.format</tt>
+  # * <tt>errors.format</tt>
+  def full_message: (untyped attribute, untyped message) -> untyped
+
+  # Translates an error message in its default scope
+  # (<tt>activemodel.errors.messages</tt>).
+  #
+  # Error messages are first looked up in <tt>activemodel.errors.models.MODEL.attributes.ATTRIBUTE.MESSAGE</tt>,
+  # if it's not there, it's looked up in <tt>activemodel.errors.models.MODEL.MESSAGE</tt> and if
+  # that is not there also, it returns the translation of the default message
+  # (e.g. <tt>activemodel.errors.messages.MESSAGE</tt>). The translated model
+  # name, translated attribute name and the value are available for
+  # interpolation.
+  #
+  # When using inheritance in your models, it will check all the inherited
+  # models too, but only if the model itself hasn't been found. Say you have
+  # <tt>class Admin < User; end</tt> and you wanted the translation for
+  # the <tt>:blank</tt> error message for the <tt>title</tt> attribute,
+  # it looks for these translations:
+  #
+  # * <tt>activemodel.errors.models.admin.attributes.title.blank</tt>
+  # * <tt>activemodel.errors.models.admin.blank</tt>
+  # * <tt>activemodel.errors.models.user.attributes.title.blank</tt>
+  # * <tt>activemodel.errors.models.user.blank</tt>
+  # * any default you provided through the +options+ hash (in the <tt>activemodel.errors</tt> scope)
+  # * <tt>activemodel.errors.messages.blank</tt>
+  # * <tt>errors.attributes.title.blank</tt>
+  # * <tt>errors.messages.blank</tt>
+  def generate_message: (untyped attribute, ?::Symbol `type`, ?::Hash[untyped, untyped] options) -> untyped
+
+  def marshal_dump: () -> ::Array[untyped]
+
+  def marshal_load: (untyped array) -> untyped
+
+  def init_with: (untyped coder) -> untyped
+
+  def normalize_message: (untyped attribute, untyped message, untyped options) -> untyped
+
+  def normalize_detail: (untyped message, untyped options) -> untyped
+
+  def without_default_proc: (untyped hash) -> untyped
+
+  def apply_default_array: (untyped hash) -> untyped
+end
+
+ActiveModel::Errors::CALLBACKS_OPTIONS: ::Array[untyped]
+
+ActiveModel::Errors::MESSAGE_OPTIONS: ::Array[untyped]
+
+# Raised when a validation cannot be corrected by end users and are considered
+# exceptional.
+#
+#   class Person
+#     include ActiveModel::Validations
+#
+#     attr_accessor :name
+#
+#     validates_presence_of :name, strict: true
+#   end
+#
+#   person = Person.new
+#   person.name = nil
+#   person.valid?
+#   # => ActiveModel::StrictValidationFailed: Name can't be blank
+class ActiveModel::StrictValidationFailed < StandardError
+end
+
+# Raised when attribute values are out of range.
+class ActiveModel::RangeError < ::RangeError
+end
+
+# Raised when unknown attributes are supplied via mass assignment.
+#
+#   class Person
+#     include ActiveModel::AttributeAssignment
+#     include ActiveModel::Validations
+#   end
+#
+#   person = Person.new
+#   person.assign_attributes(name: 'Gorby')
+#   # => ActiveModel::UnknownAttributeError: unknown attribute 'name' for Person.
+class ActiveModel::UnknownAttributeError[T] < NoMethodError[T]
+  attr_reader record: untyped
+
+  attr_reader attribute: untyped
+
+  def initialize: (untyped record, untyped attribute) -> untyped
+end
+
+# Raised when forbidden attributes are used for mass assignment.
+#
+#   class Person < ActiveRecord::Base
+#   end
+#
+#   params = ActionController::Parameters.new(name: 'Bob')
+#   Person.new(params)
+#   # => ActiveModel::ForbiddenAttributesError
+#
+#   params.permit!
+#   Person.new(params)
+#   # => #<Person id: nil, name: "Bob">
+class ActiveModel::ForbiddenAttributesError < StandardError
+end
+
+module ActiveModel::ForbiddenAttributesProtection
+  def sanitize_for_mass_assignment: (untyped attributes) -> untyped
+end
+
+module ActiveModel::VERSION
+end
+
+ActiveModel::VERSION::MAJOR: ::Integer
+
+ActiveModel::VERSION::MINOR: ::Integer
+
+ActiveModel::VERSION::TINY: ::Integer
+
+ActiveModel::VERSION::PRE: ::String
+
+ActiveModel::VERSION::STRING: untyped
+
+module ActiveModel::Lint
+end
+
+# == Active \Model \Lint \Tests
+#
+# You can test whether an object is compliant with the Active \Model API by
+# including <tt>ActiveModel::Lint::Tests</tt> in your TestCase. It will
+# include tests that tell you whether your object is fully compliant,
+# or if not, which aspects of the API are not implemented.
+#
+# Note an object is not required to implement all APIs in order to work
+# with Action Pack. This module only intends to provide guidance in case
+# you want all features out of the box.
+#
+# These tests do not attempt to determine the semantic correctness of the
+# returned values. For instance, you could implement <tt>valid?</tt> to
+# always return +true+, and the tests would pass. It is up to you to ensure
+# that the values are semantically meaningful.
+#
+# Objects you pass in are expected to return a compliant object from a call
+# to <tt>to_model</tt>. It is perfectly fine for <tt>to_model</tt> to return
+# +self+.
+module ActiveModel::Lint::Tests
+  # Passes if the object's model responds to <tt>to_key</tt> and if calling
+  # this method returns +nil+ when the object is not persisted.
+  # Fails otherwise.
+  #
+  # <tt>to_key</tt> returns an Enumerable of all (primary) key attributes
+  # of the model, and is used to a generate unique DOM id for the object.
+  def test_to_key: () -> untyped
+
+  # Passes if the object's model responds to <tt>to_param</tt> and if
+  # calling this method returns +nil+ when the object is not persisted.
+  # Fails otherwise.
+  #
+  # <tt>to_param</tt> is used to represent the object's key in URLs.
+  # Implementers can decide to either raise an exception or provide a
+  # default in case the record uses a composite primary key. There are no
+  # tests for this behavior in lint because it doesn't make sense to force
+  # any of the possible implementation strategies on the implementer.
+  def test_to_param: () -> untyped
+
+  # Passes if the object's model responds to <tt>to_partial_path</tt> and if
+  # calling this method returns a string. Fails otherwise.
+  #
+  # <tt>to_partial_path</tt> is used for looking up partials. For example,
+  # a BlogPost model might return "blog_posts/blog_post".
+  def test_to_partial_path: () -> untyped
+
+  # Passes if the object's model responds to <tt>persisted?</tt> and if
+  # calling this method returns either +true+ or +false+. Fails otherwise.
+  #
+  # <tt>persisted?</tt> is used when calculating the URL for an object.
+  # If the object is not persisted, a form for that object, for instance,
+  # will route to the create action. If it is persisted, a form for the
+  # object will route to the update action.
+  def test_persisted?: () -> untyped
+
+  # Passes if the object's model responds to <tt>model_name</tt> both as
+  # an instance method and as a class method, and if calling this method
+  # returns a string with some convenience methods: <tt>:human</tt>,
+  # <tt>:singular</tt> and <tt>:plural</tt>.
+  #
+  # Check ActiveModel::Naming for more information.
+  def test_model_naming: () -> untyped
+
+  # Passes if the object's model responds to <tt>errors</tt> and if calling
+  # <tt>[](attribute)</tt> on the result of this method returns an array.
+  # Fails otherwise.
+  #
+  # <tt>errors[attribute]</tt> is used to retrieve the errors of a model
+  # for a given attribute. If errors are present, the method should return
+  # an array of strings that are the errors for the attribute in question.
+  # If localization is used, the strings should be localized for the current
+  # locale. If no error is present, the method should return an empty array.
+  def test_errors_aref: () -> untyped
+
+  def model: () -> untyped
+
+  def assert_boolean: (untyped result, untyped name) -> untyped
+end
+
+# == Active \Model \Basic \Model
+#
+# Includes the required interface for an object to interact with
+# Action Pack and Action View, using different Active Model modules.
+# It includes model name introspections, conversions, translations and
+# validations. Besides that, it allows you to initialize the object with a
+# hash of attributes, pretty much like Active Record does.
+#
+# A minimal implementation could be:
+#
+#   class Person
+#     include ActiveModel::Model
+#     attr_accessor :name, :age
+#   end
+#
+#   person = Person.new(name: 'bob', age: '18')
+#   person.name # => "bob"
+#   person.age  # => "18"
+#
+# Note that, by default, <tt>ActiveModel::Model</tt> implements <tt>persisted?</tt>
+# to return +false+, which is the most common case. You may want to override
+# it in your class to simulate a different scenario:
+#
+#   class Person
+#     include ActiveModel::Model
+#     attr_accessor :id, :name
+#
+#     def persisted?
+#       self.id == 1
+#     end
+#   end
+#
+#   person = Person.new(id: 1, name: 'bob')
+#   person.persisted? # => true
+#
+# Also, if for some reason you need to run code on <tt>initialize</tt>, make
+# sure you call +super+ if you want the attributes hash initialization to
+# happen.
+#
+#   class Person
+#     include ActiveModel::Model
+#     attr_accessor :id, :name, :omg
+#
+#     def initialize(attributes={})
+#       super
+#       @omg ||= true
+#     end
+#   end
+#
+#   person = Person.new(id: 1, name: 'bob')
+#   person.omg # => true
+#
+# For more detailed information on other functionalities available, please
+# refer to the specific modules included in <tt>ActiveModel::Model</tt>
+# (see below).
+module ActiveModel::Model
+  extend ActiveSupport::Concern
+
+  include ActiveModel::AttributeAssignment
+
+  include ActiveModel::Validations
+
+  include ActiveModel::Conversion
+
+  extend ActiveModel::Naming
+
+  extend ActiveModel::Translation
+
+  # Initializes a new model with the given +params+.
+  #
+  #   class Person
+  #     include ActiveModel::Model
+  #     attr_accessor :name, :age
+  #   end
+  #
+  #   person = Person.new(name: 'bob', age: '18')
+  #   person.name # => "bob"
+  #   person.age  # => "18"
+  def initialize: (?::Hash[untyped, untyped] attributes) -> untyped
+
+  # Indicates if the model is persisted. Default is +false+.
+  #
+  #  class Person
+  #    include ActiveModel::Model
+  #    attr_accessor :id, :name
+  #  end
+  #
+  #  person = Person.new(id: 1, name: 'bob')
+  #  person.persisted? # => false
+  def persisted?: () -> ::FalseClass
+end
+
+class ActiveModel::Name
+  include Comparable
+
+  attr_reader singular: untyped
+
+  attr_reader plural: untyped
+
+  attr_reader element: untyped
+
+  attr_reader collection: untyped
+
+  attr_reader singular_route_key: untyped
+
+  attr_reader route_key: untyped
+
+  attr_reader param_key: untyped
+
+  attr_reader i18n_key: untyped
+
+  attr_reader name: untyped
+
+  # Returns a new ActiveModel::Name instance. By default, the +namespace+
+  # and +name+ option will take the namespace and name of the given class
+  # respectively.
+  #
+  #   module Foo
+  #     class Bar
+  #     end
+  #   end
+  #
+  #   ActiveModel::Name.new(Foo::Bar).to_s
+  #   # => "Foo::Bar"
+  def initialize: (untyped klass, ?untyped? namespace, ?untyped? name) -> untyped
+
+  # Transform the model name into a more human format, using I18n. By default,
+  # it will underscore then humanize the class name.
+  #
+  #   class BlogPost
+  #     extend ActiveModel::Naming
+  #   end
+  #
+  #   BlogPost.model_name.human # => "Blog post"
+  #
+  # Specify +options+ with additional translating options.
+  def human: (?::Hash[untyped, untyped] options) -> untyped
+
+  def _singularize: (untyped string) -> untyped
+end
+
+# == Active \Model \Naming
+#
+# Creates a +model_name+ method on your object.
+#
+# To implement, just extend ActiveModel::Naming in your object:
+#
+#   class BookCover
+#     extend ActiveModel::Naming
+#   end
+#
+#   BookCover.model_name.name   # => "BookCover"
+#   BookCover.model_name.human  # => "Book cover"
+#
+#   BookCover.model_name.i18n_key              # => :book_cover
+#   BookModule::BookCover.model_name.i18n_key  # => :"book_module/book_cover"
+#
+# Providing the functionality that ActiveModel::Naming provides in your object
+# is required to pass the \Active \Model Lint test. So either extending the
+# provided method below, or rolling your own is required.
+module ActiveModel::Naming
+  def self.extended: (untyped base) -> untyped
+
+  # Returns an ActiveModel::Name object for module. It can be
+  # used to retrieve all kinds of naming-related information
+  # (See ActiveModel::Name for more information).
+  #
+  #   class Person
+  #     extend ActiveModel::Naming
+  #   end
+  #
+  #   Person.model_name.name     # => "Person"
+  #   Person.model_name.class    # => ActiveModel::Name
+  #   Person.model_name.singular # => "person"
+  #   Person.model_name.plural   # => "people"
+  def model_name: () -> untyped
+
+  # Returns the plural class name of a record or class.
+  #
+  #   ActiveModel::Naming.plural(post)             # => "posts"
+  #   ActiveModel::Naming.plural(Highrise::Person) # => "highrise_people"
+  def self.plural: (untyped record_or_class) -> untyped
+
+  # Returns the singular class name of a record or class.
+  #
+  #   ActiveModel::Naming.singular(post)             # => "post"
+  #   ActiveModel::Naming.singular(Highrise::Person) # => "highrise_person"
+  def self.singular: (untyped record_or_class) -> untyped
+
+  # Identifies whether the class name of a record or class is uncountable.
+  #
+  #   ActiveModel::Naming.uncountable?(Sheep) # => true
+  #   ActiveModel::Naming.uncountable?(Post)  # => false
+  def self.uncountable?: (untyped record_or_class) -> untyped
+
+  # Returns string to use while generating route names. It differs for
+  # namespaced models regarding whether it's inside isolated engine.
+  #
+  #   # For isolated engine:
+  #   ActiveModel::Naming.singular_route_key(Blog::Post) # => "post"
+  #
+  #   # For shared engine:
+  #   ActiveModel::Naming.singular_route_key(Blog::Post) # => "blog_post"
+  def self.singular_route_key: (untyped record_or_class) -> untyped
+
+  # Returns string to use while generating route names. It differs for
+  # namespaced models regarding whether it's inside isolated engine.
+  #
+  #   # For isolated engine:
+  #   ActiveModel::Naming.route_key(Blog::Post) # => "posts"
+  #
+  #   # For shared engine:
+  #   ActiveModel::Naming.route_key(Blog::Post) # => "blog_posts"
+  #
+  # The route key also considers if the noun is uncountable and, in
+  # such cases, automatically appends _index.
+  def self.route_key: (untyped record_or_class) -> untyped
+
+  # Returns string to use for params names. It differs for
+  # namespaced models regarding whether it's inside isolated engine.
+  #
+  #   # For isolated engine:
+  #   ActiveModel::Naming.param_key(Blog::Post) # => "post"
+  #
+  #   # For shared engine:
+  #   ActiveModel::Naming.param_key(Blog::Post) # => "blog_post"
+  def self.param_key: (untyped record_or_class) -> untyped
+
+  def self.model_name_from_record_or_class: (untyped record_or_class) -> untyped
+end
+
+class ActiveModel::Railtie < Rails::Railtie
+end
+
+module ActiveModel::Serializers
+  extend ActiveSupport::Autoload
+end
+
+module ActiveModel::SecurePassword
+  extend ActiveSupport::Concern
+
+  attr_accessor min_cost: untyped
+end
+
+# BCrypt hash function can handle maximum 72 bytes, and if we pass
+# password of length more than 72 bytes it ignores extra characters.
+# Hence need to put a restriction on password length.
+ActiveModel::SecurePassword::MAX_PASSWORD_LENGTH_ALLOWED: ::Integer
+
+module ActiveModel::SecurePassword::ClassMethods
+  # Adds methods to set and authenticate against a BCrypt password.
+  # This mechanism requires you to have a +XXX_digest+ attribute.
+  # Where +XXX+ is the attribute name of your desired password.
+  #
+  # The following validations are added automatically:
+  # * Password must be present on creation
+  # * Password length should be less than or equal to 72 bytes
+  # * Confirmation of password (using a +XXX_confirmation+ attribute)
+  #
+  # If confirmation validation is not needed, simply leave out the
+  # value for +XXX_confirmation+ (i.e. don't provide a form field for
+  # it). When this attribute has a +nil+ value, the validation will not be
+  # triggered.
+  #
+  # For further customizability, it is possible to suppress the default
+  # validations by passing <tt>validations: false</tt> as an argument.
+  #
+  # Add bcrypt (~> 3.1.7) to Gemfile to use #has_secure_password:
+  #
+  #   gem 'bcrypt', '~> 3.1.7'
+  #
+  # Example using Active Record (which automatically includes ActiveModel::SecurePassword):
+  #
+  #   # Schema: User(name:string, password_digest:string, recovery_password_digest:string)
+  #   class User < ActiveRecord::Base
+  #     has_secure_password
+  #     has_secure_password :recovery_password, validations: false
+  #   end
+  #
+  #   user = User.new(name: 'david', password: '', password_confirmation: 'nomatch')
+  #   user.save                                                       # => false, password required
+  #   user.password = 'mUc3m00RsqyRe'
+  #   user.save                                                       # => false, confirmation doesn't match
+  #   user.password_confirmation = 'mUc3m00RsqyRe'
+  #   user.save                                                       # => true
+  #   user.recovery_password = "42password"
+  #   user.recovery_password_digest                                   # => "$2a$04$iOfhwahFymCs5weB3BNH/uXkTG65HR.qpW.bNhEjFP3ftli3o5DQC"
+  #   user.save                                                       # => true
+  #   user.authenticate('notright')                                   # => false
+  #   user.authenticate('mUc3m00RsqyRe')                              # => user
+  #   user.authenticate_recovery_password('42password')               # => user
+  #   User.find_by(name: 'david').try(:authenticate, 'notright')      # => false
+  #   User.find_by(name: 'david').try(:authenticate, 'mUc3m00RsqyRe') # => user
+  def has_secure_password: (?::Symbol attribute, ?validations: bool validations) -> untyped
+end
+
+class ActiveModel::SecurePassword::InstanceMethodsOnActivation < Module
+  def initialize: (untyped attribute) -> untyped
+end
+
+# == Active \Model \Serialization
+#
+# Provides a basic serialization to a serializable_hash for your objects.
+#
+# A minimal implementation could be:
+#
+#   class Person
+#     include ActiveModel::Serialization
+#
+#     attr_accessor :name
+#
+#     def attributes
+#       {'name' => nil}
+#     end
+#   end
+#
+# Which would provide you with:
+#
+#   person = Person.new
+#   person.serializable_hash   # => {"name"=>nil}
+#   person.name = "Bob"
+#   person.serializable_hash   # => {"name"=>"Bob"}
+#
+# An +attributes+ hash must be defined and should contain any attributes you
+# need to be serialized. Attributes must be strings, not symbols.
+# When called, serializable hash will use instance methods that match the name
+# of the attributes hash's keys. In order to override this behavior, take a look
+# at the private method +read_attribute_for_serialization+.
+#
+# ActiveModel::Serializers::JSON module automatically includes
+# the <tt>ActiveModel::Serialization</tt> module, so there is no need to
+# explicitly include <tt>ActiveModel::Serialization</tt>.
+#
+# A minimal implementation including JSON would be:
+#
+#   class Person
+#     include ActiveModel::Serializers::JSON
+#
+#     attr_accessor :name
+#
+#     def attributes
+#       {'name' => nil}
+#     end
+#   end
+#
+# Which would provide you with:
+#
+#   person = Person.new
+#   person.serializable_hash   # => {"name"=>nil}
+#   person.as_json             # => {"name"=>nil}
+#   person.to_json             # => "{\"name\":null}"
+#
+#   person.name = "Bob"
+#   person.serializable_hash   # => {"name"=>"Bob"}
+#   person.as_json             # => {"name"=>"Bob"}
+#   person.to_json             # => "{\"name\":\"Bob\"}"
+#
+# Valid options are <tt>:only</tt>, <tt>:except</tt>, <tt>:methods</tt> and
+# <tt>:include</tt>. The following are all valid examples:
+#
+#   person.serializable_hash(only: 'name')
+#   person.serializable_hash(include: :address)
+#   person.serializable_hash(include: { address: { only: 'city' }})
+module ActiveModel::Serialization
+  # Returns a serialized hash of your object.
+  #
+  #   class Person
+  #     include ActiveModel::Serialization
+  #
+  #     attr_accessor :name, :age
+  #
+  #     def attributes
+  #       {'name' => nil, 'age' => nil}
+  #     end
+  #
+  #     def capitalized_name
+  #       name.capitalize
+  #     end
+  #   end
+  #
+  #   person = Person.new
+  #   person.name = 'bob'
+  #   person.age  = 22
+  #   person.serializable_hash                # => {"name"=>"bob", "age"=>22}
+  #   person.serializable_hash(only: :name)   # => {"name"=>"bob"}
+  #   person.serializable_hash(except: :name) # => {"age"=>22}
+  #   person.serializable_hash(methods: :capitalized_name)
+  #   # => {"name"=>"bob", "age"=>22, "capitalized_name"=>"Bob"}
+  #
+  # Example with <tt>:include</tt> option
+  #
+  #   class User
+  #     include ActiveModel::Serializers::JSON
+  #     attr_accessor :name, :notes # Emulate has_many :notes
+  #     def attributes
+  #       {'name' => nil}
+  #     end
+  #   end
+  #
+  #   class Note
+  #     include ActiveModel::Serializers::JSON
+  #     attr_accessor :title, :text
+  #     def attributes
+  #       {'title' => nil, 'text' => nil}
+  #     end
+  #   end
+  #
+  #   note = Note.new
+  #   note.title = 'Battle of Austerlitz'
+  #   note.text = 'Some text here'
+  #
+  #   user = User.new
+  #   user.name = 'Napoleon'
+  #   user.notes = [note]
+  #
+  #   user.serializable_hash
+  #   # => {"name" => "Napoleon"}
+  #   user.serializable_hash(include: { notes: { only: 'title' }})
+  #   # => {"name" => "Napoleon", "notes" => [{"title"=>"Battle of Austerlitz"}]}
+  def serializable_hash: (?untyped? options) -> untyped
+
+  def serializable_add_includes: (?::Hash[untyped, untyped] options) { (untyped, untyped, untyped) -> untyped } -> (nil | untyped)
+end
+
+# == Active \Model \JSON \Serializer
+module ActiveModel::Serializers::JSON
+  extend ActiveSupport::Concern
+
+  include ActiveModel::Serialization
+
+  extend ActiveModel::Naming
+
+  # Returns a hash representing the model. Some configuration can be
+  # passed through +options+.
+  #
+  # The option <tt>include_root_in_json</tt> controls the top-level behavior
+  # of +as_json+. If +true+, +as_json+ will emit a single root node named
+  # after the object's type. The default value for <tt>include_root_in_json</tt>
+  # option is +false+.
+  #
+  #   user = User.find(1)
+  #   user.as_json
+  #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
+  #   #     "created_at" => "2006-08-01T17:27:133.000Z", "awesome" => true}
+  #
+  #   ActiveRecord::Base.include_root_in_json = true
+  #
+  #   user.as_json
+  #   # => { "user" => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
+  #   #                  "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true } }
+  #
+  # This behavior can also be achieved by setting the <tt>:root</tt> option
+  # to +true+ as in:
+  #
+  #   user = User.find(1)
+  #   user.as_json(root: true)
+  #   # => { "user" => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
+  #   #                  "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true } }
+  #
+  # Without any +options+, the returned Hash will include all the model's
+  # attributes.
+  #
+  #   user = User.find(1)
+  #   user.as_json
+  #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
+  #   #      "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true}
+  #
+  # The <tt>:only</tt> and <tt>:except</tt> options can be used to limit
+  # the attributes included, and work similar to the +attributes+ method.
+  #
+  #   user.as_json(only: [:id, :name])
+  #   # => { "id" => 1, "name" => "Konata Izumi" }
+  #
+  #   user.as_json(except: [:id, :created_at, :age])
+  #   # => { "name" => "Konata Izumi", "awesome" => true }
+  #
+  # To include the result of some method calls on the model use <tt>:methods</tt>:
+  #
+  #   user.as_json(methods: :permalink)
+  #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
+  #   #      "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true,
+  #   #      "permalink" => "1-konata-izumi" }
+  #
+  # To include associations use <tt>:include</tt>:
+  #
+  #   user.as_json(include: :posts)
+  #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
+  #   #      "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true,
+  #   #      "posts" => [ { "id" => 1, "author_id" => 1, "title" => "Welcome to the weblog" },
+  #   #                   { "id" => 2, "author_id" => 1, "title" => "So I was thinking" } ] }
+  #
+  # Second level and higher order associations work as well:
+  #
+  #   user.as_json(include: { posts: {
+  #                              include: { comments: {
+  #                                             only: :body } },
+  #                              only: :title } })
+  #   # => { "id" => 1, "name" => "Konata Izumi", "age" => 16,
+  #   #      "created_at" => "2006-08-01T17:27:13.000Z", "awesome" => true,
+  #   #      "posts" => [ { "comments" => [ { "body" => "1st post!" }, { "body" => "Second!" } ],
+  #   #                     "title" => "Welcome to the weblog" },
+  #   #                   { "comments" => [ { "body" => "Don't think too hard" } ],
+  #   #                     "title" => "So I was thinking" } ] }
+  def as_json: (?untyped? options) -> untyped
+
+  # Sets the model +attributes+ from a JSON string. Returns +self+.
+  #
+  #   class Person
+  #     include ActiveModel::Serializers::JSON
+  #
+  #     attr_accessor :name, :age, :awesome
+  #
+  #     def attributes=(hash)
+  #       hash.each do |key, value|
+  #         send("#{key}=", value)
+  #       end
+  #     end
+  #
+  #     def attributes
+  #       instance_values
+  #     end
+  #   end
+  #
+  #   json = { name: 'bob', age: 22, awesome:true }.to_json
+  #   person = Person.new
+  #   person.from_json(json) # => #<Person:0x007fec5e7a0088 @age=22, @awesome=true, @name="bob">
+  #   person.name            # => "bob"
+  #   person.age             # => 22
+  #   person.awesome         # => true
+  #
+  # The default value for +include_root+ is +false+. You can change it to
+  # +true+ if the given JSON string includes a single root node.
+  #
+  #   json = { person: { name: 'bob', age: 22, awesome:true } }.to_json
+  #   person = Person.new
+  #   person.from_json(json, true) # => #<Person:0x007fec5e7a0088 @age=22, @awesome=true, @name="bob">
+  #   person.name                  # => "bob"
+  #   person.age                   # => 22
+  #   person.awesome               # => true
+  def from_json: (untyped json, ?untyped include_root) -> untyped
+end
+
+# == Active \Model \Translation
+#
+# Provides integration between your object and the Rails internationalization
+# (i18n) framework.
+#
+# A minimal implementation could be:
+#
+#   class TranslatedPerson
+#     extend ActiveModel::Translation
+#   end
+#
+#   TranslatedPerson.human_attribute_name('my_attribute')
+#   # => "My attribute"
+#
+# This also provides the required class methods for hooking into the
+# Rails internationalization API, including being able to define a
+# class based +i18n_scope+ and +lookup_ancestors+ to find translations in
+# parent classes.
+module ActiveModel::Translation
+  include ActiveModel::Naming
+
+  # Returns the +i18n_scope+ for the class. Overwrite if you want custom lookup.
+  def i18n_scope: () -> :activemodel
+
+  # When localizing a string, it goes through the lookup returned by this
+  # method, which is used in ActiveModel::Name#human,
+  # ActiveModel::Errors#full_messages and
+  # ActiveModel::Translation#human_attribute_name.
+  def lookup_ancestors: () -> untyped
+
+  # Transforms attribute names into a more human format, such as "First name"
+  # instead of "first_name".
+  #
+  #   Person.human_attribute_name("first_name") # => "First name"
+  #
+  # Specify +options+ with additional translating options.
+  def human_attribute_name: (untyped attribute, ?::Hash[untyped, untyped] options) -> untyped
+end
+
+module ActiveModel::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
+
+class ActiveModel::Type::BigInteger < Integer
+  def max_value: () -> untyped
+end
+
+class ActiveModel::Type::Binary < Value
+  # :nodoc:
+  def `type`: () -> :binary
+
+  def binary?: () -> ::TrueClass
+
+  def cast: (untyped value) -> untyped
+
+  def serialize: (untyped value) -> (nil | untyped)
+
+  def changed_in_place?: (untyped raw_old_value, untyped value) -> untyped
+end
+
+class ActiveModel::Type::Binary::Data
+  # :nodoc:
+  def initialize: (untyped value) -> untyped
+
+  def to_s: () -> untyped
+
+  def hex: () -> untyped
+
+  def ==: (untyped other) -> untyped
+end
+
+# == Active \Model \Type \Boolean
+#
+# A class that behaves like a boolean type, including rules for coercion of user input.
+#
+# === Coercion
+# Values set from user input will first be coerced into the appropriate ruby type.
+# Coercion behavior is roughly mapped to Ruby's boolean semantics.
+#
+# - "false", "f" , "0", +0+ or any other value in +FALSE_VALUES+ will be coerced to +false+
+# - Empty strings are coerced to +nil+
+# - All other values will be coerced to +true+
+class ActiveModel::Type::Boolean < Value
+  def `type`: () -> :boolean
+
+  def serialize: (untyped value) -> untyped
+
+  def cast_value: (untyped value) -> untyped
+end
+
+ActiveModel::Type::Boolean::FALSE_VALUES: untyped
+
+class ActiveModel::Type::Date < Value
+  # :nodoc:
+  include Helpers::Timezone
+
+  def `type`: () -> :date
+
+  def type_cast_for_schema: (untyped value) -> untyped
+
+  def cast_value: (untyped value) -> untyped
+
+  def fast_string_to_date: (untyped string) -> untyped
+
+  def fallback_string_to_date: (untyped string) -> untyped
+
+  def new_date: (untyped year, untyped mon, untyped mday) -> untyped
+
+  def value_from_multiparameter_assignment: () -> untyped
+end
+
+ActiveModel::Type::Date::ISO_DATE: untyped
+
+class ActiveModel::Type::DateTime < Value
+  # :nodoc:
+  include Helpers::Timezone
+
+  include Helpers::TimeValue
+
+  def `type`: () -> :datetime
+
+  def cast_value: (untyped value) -> (untyped | nil)
+
+  # '0.123456' -> 123456
+  # '1.123456' -> 123456
+  def microseconds: (untyped time) -> untyped
+
+  def fallback_string_to_time: (untyped string) -> untyped
+
+  def value_from_multiparameter_assignment: (untyped values_hash) -> untyped
+end
+
+class ActiveModel::Type::Decimal < Value
+  # :nodoc:
+  include Helpers::Numeric
+
+  def `type`: () -> :decimal
+
+  def type_cast_for_schema: (untyped value) -> untyped
+
+  def cast_value: (untyped value) -> untyped
+
+  def convert_float_to_big_decimal: (untyped value) -> untyped
+
+  def float_precision: () -> untyped
+
+  def apply_scale: (untyped value) -> untyped
+end
+
+ActiveModel::Type::Decimal::BIGDECIMAL_PRECISION: ::Integer
+
+class ActiveModel::Type::Float < Value
+  # :nodoc:
+  include Helpers::Numeric
+
+  def `type`: () -> :float
+
+  def type_cast_for_schema: (untyped value) -> ("::Float::NAN" | untyped)
+
+  def cast_value: (untyped value) -> untyped
+end
+
+module ActiveModel::Type::Helpers
+end
+
+# :nodoc: all
+class ActiveModel::Type::Helpers::AcceptsMultiparameterTime < Module
+  def initialize: (?defaults: ::Hash[untyped, untyped] defaults) -> (nil | untyped)
+end
+
+# :nodoc: all
+module ActiveModel::Type::Helpers::Mutable
+  def cast: (untyped value) -> untyped
+
+  # +raw_old_value+ will be the `_before_type_cast` version of the
+  # value (likely a string). +new_value+ will be the current, type
+  # cast value.
+  def changed_in_place?: (untyped raw_old_value, untyped new_value) -> untyped
+end
+
+# :nodoc: all
+module ActiveModel::Type::Helpers::Numeric
+  def serialize: (untyped value) -> untyped
+
+  def cast: (untyped value) -> untyped
+
+  def changed?: (untyped old_value, untyped _new_value, untyped new_value_before_type_cast) -> untyped
+
+  def number_to_non_number?: (untyped old_value, untyped new_value_before_type_cast) -> untyped
+
+  def non_numeric_string?: (untyped value) -> untyped
+end
+
+ActiveModel::Type::Helpers::Numeric::NUMERIC_REGEX: untyped
+
+# :nodoc: all
+module ActiveModel::Type::Helpers::TimeValue
+  def serialize: (untyped value) -> untyped
+
+  def apply_seconds_precision: (untyped value) -> untyped
+
+  def type_cast_for_schema: (untyped value) -> untyped
+
+  def user_input_in_time_zone: (untyped value) -> untyped
+
+  def new_time: (untyped year, untyped mon, untyped mday, untyped hour, untyped min, untyped sec, untyped microsec, ?untyped? offset) -> (nil | untyped)
+
+  # Doesn't handle time zones.
+  def fast_string_to_time: (untyped string) -> untyped
+end
+
+ActiveModel::Type::Helpers::TimeValue::ISO_DATETIME: untyped
+
+# :nodoc: all
+module ActiveModel::Type::Helpers::Timezone
+  def is_utc?: () -> untyped
+
+  def default_timezone: () -> untyped
+end
+
+class ActiveModel::Type::ImmutableString < Value
+  # :nodoc:
+  def `type`: () -> :string
+
+  def serialize: (untyped value) -> untyped
+
+  def cast_value: (untyped value) -> untyped
+end
+
+class ActiveModel::Type::Integer < Value
+  # :nodoc:
+  include Helpers::Numeric
+
+  def initialize: () -> untyped
+
+  def `type`: () -> :integer
+
+  def deserialize: (untyped value) -> (nil | untyped)
+
+  def serialize: (untyped value) -> (nil | untyped)
+
+  attr_reader range: untyped
+
+  def cast_value: (untyped value) -> untyped
+
+  def ensure_in_range: (untyped value) -> untyped
+
+  def max_value: () -> untyped
+
+  def min_value: () -> untyped
+
+  def _limit: () -> untyped
+end
+
+# Column storage size in bytes.
+# 4 bytes means an integer as opposed to smallint etc.
+ActiveModel::Type::Integer::DEFAULT_LIMIT: ::Integer
+
+class ActiveModel::Type::Registry
+  def initialize: () -> untyped
+
+  def register: (untyped type_name, ?untyped? klass, **untyped options) { () -> untyped } -> untyped
+
+  def lookup: (untyped symbol, *untyped args, **untyped kwargs) -> untyped
+
+  attr_reader registrations: untyped
+
+  def registration_klass: () -> untyped
+
+  def find_registration: (untyped symbol, *untyped args) -> untyped
+end
+
+class ActiveModel::Type::Registration
+  # Options must be taken because of https://bugs.ruby-lang.org/issues/10856
+  def initialize: (untyped name, untyped block) -> untyped
+
+  def call: (untyped _registry, *untyped args, **untyped kwargs) -> untyped
+
+  def matches?: (untyped type_name, *untyped args, **untyped kwargs) -> untyped
+
+  attr_reader name: untyped
+
+  attr_reader block: untyped
+end
+
+class ActiveModel::Type::String < ImmutableString
+  # :nodoc:
+  def changed_in_place?: (untyped raw_old_value, untyped new_value) -> untyped
+
+  def cast_value: (untyped value) -> untyped
+end
+
+class ActiveModel::Type::Time < Value
+  # :nodoc:
+  include Helpers::Timezone
+
+  include Helpers::TimeValue
+
+  def `type`: () -> :time
+
+  def user_input_in_time_zone: (untyped value) -> (nil | untyped)
+
+  def cast_value: (untyped value) -> (untyped | nil)
+end
+
+class ActiveModel::Type::Value
+  attr_reader precision: untyped
+
+  attr_reader scale: untyped
+
+  attr_reader limit: untyped
+
+  def initialize: (?scale: untyped? scale, ?limit: untyped? limit, ?precision: untyped? precision) -> untyped
+
+  def `type`: () -> nil
+
+  # Converts a value from database input to the appropriate ruby type. The
+  # return value of this method will be returned from
+  # ActiveRecord::AttributeMethods::Read#read_attribute. The default
+  # implementation just calls Value#cast.
+  #
+  # +value+ The raw input, as provided from the database.
+  def deserialize: (untyped value) -> untyped
+
+  # Type casts a value from user input (e.g. from a setter). This value may
+  # be a string from the form builder, or a ruby object passed to a setter.
+  # There is currently no way to differentiate between which source it came
+  # from.
+  #
+  # The return value of this method will be returned from
+  # ActiveRecord::AttributeMethods::Read#read_attribute. See also:
+  # Value#cast_value.
+  #
+  # +value+ The raw input, as provided to the attribute setter.
+  def cast: (untyped value) -> untyped
+
+  # Casts a value from the ruby type to a type that the database knows how
+  # to understand. The returned value from this method should be a
+  # +String+, +Numeric+, +Date+, +Time+, +Symbol+, +true+, +false+, or
+  # +nil+.
+  def serialize: (untyped value) -> untyped
+
+  def type_cast_for_schema: (untyped value) -> untyped
+
+  def binary?: () -> ::FalseClass
+
+  # Determines whether a value has changed for dirty checking. +old_value+
+  # and +new_value+ will always be type-cast. Types should not need to
+  # override this method.
+  def changed?: (untyped old_value, untyped new_value, untyped _new_value_before_type_cast) -> untyped
+
+  # Determines whether the mutable value has been modified since it was
+  # read. Returns +false+ by default. If your type returns an object
+  # which could be mutated, you should override this method. You will need
+  # to either:
+  #
+  # - pass +new_value+ to Value#serialize and compare it to
+  #   +raw_old_value+
+  #
+  # or
+  #
+  # - pass +raw_old_value+ to Value#deserialize and compare it to
+  #   +new_value+
+  #
+  # +raw_old_value+ The original value, before being passed to
+  # +deserialize+.
+  #
+  # +new_value+ The current value, after type casting.
+  def changed_in_place?: (untyped raw_old_value, untyped new_value) -> ::FalseClass
+
+  def value_constructed_by_mass_assignment?: (untyped _value) -> ::FalseClass
+
+  def force_equality?: (untyped _value) -> ::FalseClass
+
+  def map: (untyped value) { (untyped) -> untyped } -> untyped
+
+  def ==: (untyped other) -> untyped
+
+  def hash: () -> untyped
+
+  def assert_valid_value: () -> nil
+
+  def cast_value: (untyped value) -> untyped
+end
+
+module ActiveModel::Validations
+  extend ActiveSupport::Concern
+
+  extend ActiveModel::Naming
+
+  extend ActiveModel::Callbacks
+
+  extend ActiveModel::Translation
+
+  extend HelperMethods
+
+  include HelperMethods
+
+  attr_accessor validation_context: untyped
+
+  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
+
+  # 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
+
+class ActiveModel::Validations::AbsenceValidator < EachValidator
+  # == \Active \Model Absence Validator
+  # nodoc:
+  def validate_each: (untyped record, untyped attr_name, untyped value) -> untyped
+end
+
+module ActiveModel::Validations::HelperMethods
+  # Validates that the specified attributes are blank (as defined by
+  # Object#present?). Happens by default on save.
+  #
+  #   class Person < ActiveRecord::Base
+  #     validates_absence_of :first_name
+  #   end
+  #
+  # The first_name attribute must be in the object and it must be blank.
+  #
+  # Configuration options:
+  # * <tt>:message</tt> - A custom error message (default is: "must be blank").
+  #
+  # There is also a list of default options supported by every validator:
+  # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
+  # See <tt>ActiveModel::Validations#validates</tt> for more information
+  def validates_absence_of: (*untyped attr_names) -> untyped
+
+  # Encapsulates the pattern of wanting to validate the acceptance of a
+  # terms of service check box (or similar agreement).
+  #
+  #   class Person < ActiveRecord::Base
+  #     validates_acceptance_of :terms_of_service
+  #     validates_acceptance_of :eula, message: 'must be abided'
+  #   end
+  #
+  # If the database column does not exist, the +terms_of_service+ attribute
+  # is entirely virtual. This check is performed only if +terms_of_service+
+  # is not +nil+ and by default on save.
+  #
+  # Configuration options:
+  # * <tt>:message</tt> - A custom error message (default is: "must be
+  #   accepted").
+  # * <tt>:accept</tt> - Specifies a value that is considered accepted.
+  #   Also accepts an array of possible values. The default value is
+  #   an array ["1", true], which makes it easy to relate to an HTML
+  #   checkbox. This should be set to, or include, +true+ if you are validating
+  #   a database column, since the attribute is typecast from "1" to +true+
+  #   before validation.
+  #
+  # There is also a list of default options supported by every validator:
+  # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
+  # See <tt>ActiveModel::Validations#validates</tt> for more information.
+  def validates_acceptance_of: (*untyped attr_names) -> untyped
+
+  # Encapsulates the pattern of wanting to validate a password or email
+  # address field with a confirmation.
+  #
+  #   Model:
+  #     class Person < ActiveRecord::Base
+  #       validates_confirmation_of :user_name, :password
+  #       validates_confirmation_of :email_address,
+  #                                 message: 'should match confirmation'
+  #     end
+  #
+  #   View:
+  #     <%= password_field "person", "password" %>
+  #     <%= password_field "person", "password_confirmation" %>
+  #
+  # The added +password_confirmation+ attribute is virtual; it exists only
+  # as an in-memory attribute for validating the password. To achieve this,
+  # the validation adds accessors to the model for the confirmation
+  # attribute.
+  #
+  # NOTE: This check is performed only if +password_confirmation+ is not
+  # +nil+. To require confirmation, make sure to add a presence check for
+  # the confirmation attribute:
+  #
+  #   validates_presence_of :password_confirmation, if: :password_changed?
+  #
+  # Configuration options:
+  # * <tt>:message</tt> - A custom error message (default is: "doesn't match
+  #   <tt>%{translated_attribute_name}</tt>").
+  # * <tt>:case_sensitive</tt> - Looks for an exact match. Ignored by
+  #   non-text columns (+true+ by default).
+  #
+  # There is also a list of default options supported by every validator:
+  # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
+  # See <tt>ActiveModel::Validations#validates</tt> for more information
+  def validates_confirmation_of: (*untyped attr_names) -> untyped
+
+  # Validates that the value of the specified attribute is not in a
+  # particular enumerable object.
+  #
+  #   class Person < ActiveRecord::Base
+  #     validates_exclusion_of :username, in: %w( admin superuser ), message: "You don't belong here"
+  #     validates_exclusion_of :age, in: 30..60, message: 'This site is only for under 30 and over 60'
+  #     validates_exclusion_of :format, in: %w( mov avi ), message: "extension %{value} is not allowed"
+  #     validates_exclusion_of :password, in: ->(person) { [person.username, person.first_name] },
+  #                            message: 'should not be the same as your username or first name'
+  #     validates_exclusion_of :karma, in: :reserved_karmas
+  #   end
+  #
+  # Configuration options:
+  # * <tt>:in</tt> - An enumerable object of items that the value shouldn't
+  #   be part of. This can be supplied as a proc, lambda or symbol which returns an
+  #   enumerable. If the enumerable is a numerical, time or datetime range the test
+  #   is performed with <tt>Range#cover?</tt>, otherwise with <tt>include?</tt>. When
+  #   using a proc or lambda the instance under validation is passed as an argument.
+  # * <tt>:within</tt> - A synonym(or alias) for <tt>:in</tt>
+  #   <tt>Range#cover?</tt>, otherwise with <tt>include?</tt>.
+  # * <tt>:message</tt> - Specifies a custom error message (default is: "is
+  #   reserved").
+  #
+  # There is also a list of default options supported by every validator:
+  # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
+  # See <tt>ActiveModel::Validations#validates</tt> for more information
+  def validates_exclusion_of: (*untyped attr_names) -> untyped
+
+  # Validates whether the value of the specified attribute is of the correct
+  # form, going by the regular expression provided. You can require that the
+  # attribute matches the regular expression:
+  #
+  #   class Person < ActiveRecord::Base
+  #     validates_format_of :email, with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i, on: :create
+  #   end
+  #
+  # Alternatively, you can require that the specified attribute does _not_
+  # match the regular expression:
+  #
+  #   class Person < ActiveRecord::Base
+  #     validates_format_of :email, without: /NOSPAM/
+  #   end
+  #
+  # You can also provide a proc or lambda which will determine the regular
+  # expression that will be used to validate the attribute.
+  #
+  #   class Person < ActiveRecord::Base
+  #     # Admin can have number as a first letter in their screen name
+  #     validates_format_of :screen_name,
+  #                         with: ->(person) { person.admin? ? /\A[a-z0-9][a-z0-9_\-]*\z/i : /\A[a-z][a-z0-9_\-]*\z/i }
+  #   end
+  #
+  # Note: use <tt>\A</tt> and <tt>\z</tt> to match the start and end of the
+  # string, <tt>^</tt> and <tt>$</tt> match the start/end of a line.
+  #
+  # Due to frequent misuse of <tt>^</tt> and <tt>$</tt>, you need to pass
+  # the <tt>multiline: true</tt> option in case you use any of these two
+  # anchors in the provided regular expression. In most cases, you should be
+  # using <tt>\A</tt> and <tt>\z</tt>.
+  #
+  # You must pass either <tt>:with</tt> or <tt>:without</tt> as an option.
+  # In addition, both must be a regular expression or a proc or lambda, or
+  # else an exception will be raised.
+  #
+  # Configuration options:
+  # * <tt>:message</tt> - A custom error message (default is: "is invalid").
+  # * <tt>:with</tt> - Regular expression that if the attribute matches will
+  #   result in a successful validation. This can be provided as a proc or
+  #   lambda returning regular expression which will be called at runtime.
+  # * <tt>:without</tt> - Regular expression that if the attribute does not
+  #   match will result in a successful validation. This can be provided as
+  #   a proc or lambda returning regular expression which will be called at
+  #   runtime.
+  # * <tt>:multiline</tt> - Set to true if your regular expression contains
+  #   anchors that match the beginning or end of lines as opposed to the
+  #   beginning or end of the string. These anchors are <tt>^</tt> and <tt>$</tt>.
+  #
+  # There is also a list of default options supported by every validator:
+  # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
+  # See <tt>ActiveModel::Validations#validates</tt> for more information
+  def validates_format_of: (*untyped attr_names) -> untyped
+
+  def _merge_attributes: (untyped attr_names) -> untyped
+
+  # Validates whether the value of the specified attribute is available in a
+  # particular enumerable object.
+  #
+  #   class Person < ActiveRecord::Base
+  #     validates_inclusion_of :role, in: %w( admin contributor )
+  #     validates_inclusion_of :age, in: 0..99
+  #     validates_inclusion_of :format, in: %w( jpg gif png ), message: "extension %{value} is not included in the list"
+  #     validates_inclusion_of :states, in: ->(person) { STATES[person.country] }
+  #     validates_inclusion_of :karma, in: :available_karmas
+  #   end
+  #
+  # Configuration options:
+  # * <tt>:in</tt> - An enumerable object of available items. This can be
+  #   supplied as a proc, lambda or symbol which returns an enumerable. If the
+  #   enumerable is a numerical, time or datetime range the test is performed
+  #   with <tt>Range#cover?</tt>, otherwise with <tt>include?</tt>. When using
+  #   a proc or lambda the instance under validation is passed as an argument.
+  # * <tt>:within</tt> - A synonym(or alias) for <tt>:in</tt>
+  # * <tt>:message</tt> - Specifies a custom error message (default is: "is
+  #   not included in the list").
+  #
+  # There is also a list of default options supported by every validator:
+  # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
+  # See <tt>ActiveModel::Validations#validates</tt> for more information
+  def validates_inclusion_of: (*untyped attr_names) -> untyped
+
+  # Validates that the specified attributes match the length restrictions
+  # supplied. Only one constraint option can be used at a time apart from
+  # +:minimum+ and +:maximum+ that can be combined together:
+  #
+  #   class Person < ActiveRecord::Base
+  #     validates_length_of :first_name, maximum: 30
+  #     validates_length_of :last_name, maximum: 30, message: "less than 30 if you don't mind"
+  #     validates_length_of :fax, in: 7..32, allow_nil: true
+  #     validates_length_of :phone, in: 7..32, allow_blank: true
+  #     validates_length_of :user_name, within: 6..20, too_long: 'pick a shorter name', too_short: 'pick a longer name'
+  #     validates_length_of :zip_code, minimum: 5, too_short: 'please enter at least 5 characters'
+  #     validates_length_of :smurf_leader, is: 4, message: "papa is spelled with 4 characters... don't play me."
+  #     validates_length_of :words_in_essay, minimum: 100, too_short: 'Your essay must be at least 100 words.'
+  #
+  #     private
+  #
+  #     def words_in_essay
+  #       essay.scan(/\w+/)
+  #     end
+  #   end
+  #
+  # Constraint options:
+  #
+  # * <tt>:minimum</tt> - The minimum size of the attribute.
+  # * <tt>:maximum</tt> - The maximum size of the attribute. Allows +nil+ by
+  #   default if not used with +:minimum+.
+  # * <tt>:is</tt> - The exact size of the attribute.
+  # * <tt>:within</tt> - A range specifying the minimum and maximum size of
+  #   the attribute.
+  # * <tt>:in</tt> - A synonym (or alias) for <tt>:within</tt>.
+  #
+  # Other options:
+  #
+  # * <tt>:allow_nil</tt> - Attribute may be +nil+; skip validation.
+  # * <tt>:allow_blank</tt> - Attribute may be blank; skip validation.
+  # * <tt>:too_long</tt> - The error message if the attribute goes over the
+  #   maximum (default is: "is too long (maximum is %{count} characters)").
+  # * <tt>:too_short</tt> - The error message if the attribute goes under the
+  #   minimum (default is: "is too short (minimum is %{count} characters)").
+  # * <tt>:wrong_length</tt> - The error message if using the <tt>:is</tt>
+  #   method and the attribute is the wrong size (default is: "is the wrong
+  #   length (should be %{count} characters)").
+  # * <tt>:message</tt> - The error message to use for a <tt>:minimum</tt>,
+  #   <tt>:maximum</tt>, or <tt>:is</tt> violation. An alias of the appropriate
+  #   <tt>too_long</tt>/<tt>too_short</tt>/<tt>wrong_length</tt> message.
+  #
+  # There is also a list of default options supported by every validator:
+  # +:if+, +:unless+, +:on+ and +:strict+.
+  # See <tt>ActiveModel::Validations#validates</tt> for more information
+  def validates_length_of: (*untyped attr_names) -> untyped
+
+  # Validates whether the value of the specified attribute is numeric by
+  # trying to convert it to a float with Kernel.Float (if <tt>only_integer</tt>
+  # is +false+) or applying it to the regular expression <tt>/\A[\+\-]?\d+\z/</tt>
+  # (if <tt>only_integer</tt> is set to +true+).
+  #
+  #   class Person < ActiveRecord::Base
+  #     validates_numericality_of :value, on: :create
+  #   end
+  #
+  # Configuration options:
+  # * <tt>:message</tt> - A custom error message (default is: "is not a number").
+  # * <tt>:only_integer</tt> - Specifies whether the value has to be an
+  #   integer, e.g. an integral value (default is +false+).
+  # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+ (default is
+  #   +false+). Notice that for Integer and Float columns empty strings are
+  #   converted to +nil+.
+  # * <tt>:greater_than</tt> - Specifies the value must be greater than the
+  #   supplied value.
+  # * <tt>:greater_than_or_equal_to</tt> - Specifies the value must be
+  #   greater than or equal the supplied value.
+  # * <tt>:equal_to</tt> - Specifies the value must be equal to the supplied
+  #   value.
+  # * <tt>:less_than</tt> - Specifies the value must be less than the
+  #   supplied value.
+  # * <tt>:less_than_or_equal_to</tt> - Specifies the value must be less
+  #   than or equal the supplied value.
+  # * <tt>:other_than</tt> - Specifies the value must be other than the
+  #   supplied value.
+  # * <tt>:odd</tt> - Specifies the value must be an odd number.
+  # * <tt>:even</tt> - Specifies the value must be an even number.
+  #
+  # There is also a list of default options supported by every validator:
+  # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+ .
+  # See <tt>ActiveModel::Validations#validates</tt> for more information
+  #
+  # The following checks can also be supplied with a proc or a symbol which
+  # corresponds to a method:
+  #
+  # * <tt>:greater_than</tt>
+  # * <tt>:greater_than_or_equal_to</tt>
+  # * <tt>:equal_to</tt>
+  # * <tt>:less_than</tt>
+  # * <tt>:less_than_or_equal_to</tt>
+  # * <tt>:only_integer</tt>
+  #
+  # For example:
+  #
+  #   class Person < ActiveRecord::Base
+  #     validates_numericality_of :width, less_than: ->(person) { person.height }
+  #     validates_numericality_of :width, greater_than: :minimum_weight
+  #   end
+  def validates_numericality_of: (*untyped attr_names) -> untyped
+
+  # Validates that the specified attributes are not blank (as defined by
+  # Object#blank?). Happens by default on save.
+  #
+  #   class Person < ActiveRecord::Base
+  #     validates_presence_of :first_name
+  #   end
+  #
+  # The first_name attribute must be in the object and it cannot be blank.
+  #
+  # If you want to validate the presence of a boolean field (where the real
+  # values are +true+ and +false+), you will want to use
+  # <tt>validates_inclusion_of :field_name, in: [true, false]</tt>.
+  #
+  # This is due to the way Object#blank? handles boolean values:
+  # <tt>false.blank? # => true</tt>.
+  #
+  # Configuration options:
+  # * <tt>:message</tt> - A custom error message (default is: "can't be blank").
+  #
+  # There is also a list of default options supported by every validator:
+  # +:if+, +:unless+, +:on+, +:allow_nil+, +:allow_blank+, and +:strict+.
+  # See <tt>ActiveModel::Validations#validates</tt> for more information
+  def validates_presence_of: (*untyped attr_names) -> untyped
+end
+
+class ActiveModel::Validations::AcceptanceValidator < EachValidator
+  # :nodoc:
+  def initialize: (untyped options) -> untyped
+
+  def validate_each: (untyped record, untyped attribute, untyped value) -> untyped
+
+  def setup!: (untyped klass) -> untyped
+
+  def acceptable_option?: (untyped value) -> untyped
+end
+
+class ActiveModel::Validations::AcceptanceValidator::LazilyDefineAttributes < Module
+  def initialize: (untyped attributes) -> untyped
+
+  def included: (untyped klass) -> untyped
+
+  def matches?: (untyped method_name) -> untyped
+
+  def define_on: (untyped klass) -> untyped
+
+  def ==: (untyped other) -> untyped
+
+  attr_reader attributes: untyped
+end
+
+# == Active \Model \Validation \Callbacks
+#
+# Provides an interface for any class to have +before_validation+ and
+# +after_validation+ callbacks.
+#
+# First, include ActiveModel::Validations::Callbacks from the class you are
+# creating:
+#
+#   class MyModel
+#     include ActiveModel::Validations::Callbacks
+#
+#     before_validation :do_stuff_before_validation
+#     after_validation  :do_stuff_after_validation
+#   end
+#
+# Like other <tt>before_*</tt> callbacks if +before_validation+ throws
+# +:abort+ then <tt>valid?</tt> will not be called.
+module ActiveModel::Validations::Callbacks
+  extend ActiveSupport::Concern
+
+  include ActiveSupport::Callbacks
+
+  # Overwrite run validations to include callbacks.
+  def run_validations!: () -> untyped
+end
+
+module ActiveModel::Validations::Callbacks::ClassMethods
+  # Defines a callback that will get called right before validation.
+  #
+  #   class Person
+  #     include ActiveModel::Validations
+  #     include ActiveModel::Validations::Callbacks
+  #
+  #     attr_accessor :name
+  #
+  #     validates_length_of :name, maximum: 6
+  #
+  #     before_validation :remove_whitespaces
+  #
+  #     private
+  #
+  #     def remove_whitespaces
+  #       name.strip!
+  #     end
+  #   end
+  #
+  #   person = Person.new
+  #   person.name = '  bob  '
+  #   person.valid? # => true
+  #   person.name   # => "bob"
+  def before_validation: (*untyped args) { () -> untyped } -> untyped
+
+  # Defines a callback that will get called right after validation.
+  #
+  #   class Person
+  #     include ActiveModel::Validations
+  #     include ActiveModel::Validations::Callbacks
+  #
+  #     attr_accessor :name, :status
+  #
+  #     validates_presence_of :name
+  #
+  #     after_validation :set_status
+  #
+  #     private
+  #
+  #     def set_status
+  #       self.status = errors.empty?
+  #     end
+  #   end
+  #
+  #   person = Person.new
+  #   person.name = ''
+  #   person.valid? # => false
+  #   person.status # => false
+  #   person.name = 'bob'
+  #   person.valid? # => true
+  #   person.status # => true
+  def after_validation: (*untyped args) { () -> untyped } -> untyped
+end
+
+module ActiveModel::Validations::Clusivity
+  def check_validity!: () -> untyped
+
+  def include?: (untyped record, untyped value) -> untyped
+
+  def delimiter: () -> untyped
+
+  # After Ruby 2.2, <tt>Range#include?</tt> on non-number-or-time-ish ranges checks all
+  # possible values in the range for equality, which is slower but more accurate.
+  # <tt>Range#cover?</tt> uses the previous logic of comparing a value with the range
+  # endpoints, which is fast but is only accurate on Numeric, Time, Date,
+  # or DateTime ranges.
+  def inclusion_method: (untyped enumerable) -> untyped
+end
+
+# nodoc:
+ActiveModel::Validations::Clusivity::ERROR_MESSAGE: ::String
+
+class ActiveModel::Validations::ConfirmationValidator < EachValidator
+  # :nodoc:
+  def initialize: (untyped options) -> untyped
+
+  def validate_each: (untyped record, untyped attribute, untyped value) -> untyped
+
+  def setup!: (untyped klass) -> untyped
+
+  def confirmation_value_equal?: (untyped record, untyped attribute, untyped value, untyped confirmed) -> untyped
+end
+
+class ActiveModel::Validations::ExclusionValidator < EachValidator
+  # :nodoc:
+  include Clusivity
+
+  def validate_each: (untyped record, untyped attribute, untyped value) -> untyped
+end
+
+class ActiveModel::Validations::FormatValidator < EachValidator
+  # :nodoc:
+  def validate_each: (untyped record, untyped attribute, untyped value) -> untyped
+
+  def check_validity!: () -> untyped
+
+  def option_call: (untyped record, untyped name) -> untyped
+
+  def record_error: (untyped record, untyped attribute, untyped name, untyped value) -> untyped
+
+  def check_options_validity: (untyped name) -> untyped
+
+  def regexp_using_multiline_anchors?: (untyped regexp) -> untyped
+end
+
+class ActiveModel::Validations::InclusionValidator < EachValidator
+  # :nodoc:
+  include Clusivity
+
+  def validate_each: (untyped record, untyped attribute, untyped value) -> untyped
+end
+
+class ActiveModel::Validations::LengthValidator < EachValidator
+  def initialize: (untyped options) -> untyped
+
+  def check_validity!: () -> untyped
+
+  def validate_each: (untyped record, untyped attribute, untyped value) -> untyped
+
+  def skip_nil_check?: (untyped key) -> untyped
+end
+
+# :nodoc:
+ActiveModel::Validations::LengthValidator::MESSAGES: untyped
+
+ActiveModel::Validations::LengthValidator::CHECKS: untyped
+
+ActiveModel::Validations::LengthValidator::RESERVED_OPTIONS: ::Array[untyped]
+
+class ActiveModel::Validations::NumericalityValidator < EachValidator
+  def check_validity!: () -> untyped
+
+  def validate_each: (untyped record, untyped attr_name, untyped value) -> (nil | untyped)
+
+  def is_number?: (untyped raw_value) -> untyped
+
+  def parse_as_number: (untyped raw_value) -> untyped
+
+  def is_integer?: (untyped raw_value) -> untyped
+
+  def is_hexadecimal_literal?: (untyped raw_value) -> untyped
+
+  def filtered_options: (untyped value) -> untyped
+
+  def allow_only_integer?: (untyped record) -> untyped
+
+  def record_attribute_changed_in_place?: (untyped record, untyped attr_name) -> untyped
+end
+
+# :nodoc:
+ActiveModel::Validations::NumericalityValidator::CHECKS: untyped
+
+ActiveModel::Validations::NumericalityValidator::RESERVED_OPTIONS: untyped
+
+ActiveModel::Validations::NumericalityValidator::INTEGER_REGEX: untyped
+
+ActiveModel::Validations::NumericalityValidator::HEXADECIMAL_REGEX: untyped
+
+class ActiveModel::Validations::PresenceValidator < EachValidator
+  # :nodoc:
+  def validate_each: (untyped record, untyped attr_name, untyped value) -> untyped
+end
+
+module ActiveModel::Validations::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
+
+  # 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
+
+  # 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:
+  #
+  #   validates :terms, acceptance: true
+  #   validates :password, confirmation: true
+  #   validates :username, exclusion: { in: %w(admin superuser) }
+  #   validates :email, format: { with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i, on: :create }
+  #   validates :age, inclusion: { in: 0..9 }
+  #   validates :first_name, length: { maximum: 30 }
+  #   validates :age, numericality: true
+  #   validates :username, presence: true
+  #
+  # The power of the +validates+ method comes when using custom validators
+  # and default validators in one call for a given attribute.
+  #
+  #   class EmailValidator < ActiveModel::EachValidator
+  #     def validate_each(record, attribute, value)
+  #       record.errors.add attribute, (options[:message] || "is not an email") unless
+  #         value =~ /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i
+  #     end
+  #   end
+  #
+  #   class Person
+  #     include ActiveModel::Validations
+  #     attr_accessor :name, :email
+  #
+  #     validates :name, presence: true, length: { maximum: 100 }
+  #     validates :email, presence: true, email: true
+  #   end
+  #
+  # Validator classes may also exist within the class being validated
+  # allowing custom modules of validators to be included as needed.
+  #
+  #   class Film
+  #     include ActiveModel::Validations
+  #
+  #     class TitleValidator < ActiveModel::EachValidator
+  #       def validate_each(record, attribute, value)
+  #         record.errors.add attribute, "must start with 'the'" unless value =~ /\Athe/i
+  #       end
+  #     end
+  #
+  #     validates :name, title: true
+  #   end
+  #
+  # Additionally validator classes may be in another namespace and still
+  # used within any class.
+  #
+  #   validates :name, :'film/title' => true
+  #
+  # The validators hash can also handle regular expressions, ranges, arrays
+  # and strings in shortcut form.
+  #
+  #   validates :email, format: /@/
+  #   validates :role, inclusion: %(admin contributor)
+  #   validates :password, length: 6..20
+  #
+  # When using shortcut form, ranges and arrays are passed to your
+  # validator's initializer as <tt>options[:in]</tt> while other types
+  # including regular expressions and strings are passed as <tt>options[:with]</tt>.
+  #
+  # There is also a list of options that could be used along with validators:
+  #
+  # * <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>:allow_nil</tt> - Skip validation if the attribute is +nil+.
+  # * <tt>:allow_blank</tt> - Skip validation if the attribute is blank.
+  # * <tt>:strict</tt> - If the <tt>:strict</tt> option is set to true
+  #   will raise ActiveModel::StrictValidationFailed instead of adding the error.
+  #   <tt>:strict</tt> option can also be set to any other exception.
+  #
+  # Example:
+  #
+  #   validates :password, presence: true, confirmation: true, if: :password_required?
+  #   validates :token, length: 24, strict: TokenLengthException
+  #
+  #
+  # Finally, the options +:if+, +:unless+, +:on+, +:allow_blank+, +:allow_nil+, +:strict+
+  # and +:message+ can be given to one specific validator, as a hash:
+  #
+  #   validates :password, presence: { if: :password_required?, message: 'is forgotten.' }, confirmation: true
+  def validates: (*untyped attributes) -> untyped
+
+  # This method is used to define validations that cannot be corrected by end
+  # users and are considered exceptional. So each validator defined with bang
+  # or <tt>:strict</tt> option set to <tt>true</tt> will always raise
+  # <tt>ActiveModel::StrictValidationFailed</tt> instead of adding error
+  # when validation fails. See <tt>validates</tt> for more information about
+  # the validation itself.
+  #
+  #   class Person
+  #     include ActiveModel::Validations
+  #
+  #     attr_accessor :name
+  #     validates! :name, presence: true
+  #   end
+  #
+  #   person = Person.new
+  #   person.name = ''
+  #   person.valid?
+  #   # => ActiveModel::StrictValidationFailed: Name can't be blank
+  def validates!: (*untyped attributes) -> untyped
+
+  # When creating custom validators, it might be useful to be able to specify
+  # additional default keys. This can be done by overwriting this method.
+  def _validates_default_keys: () -> ::Array[:if | :unless | :on | :allow_blank | :allow_nil | :strict]
+
+  def _parse_validates_options: (untyped options) -> untyped
+
+  # 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
+  #     validates_with MyValidator
+  #   end
+  #
+  #   class MyValidator < ActiveModel::Validator
+  #     def validate(record)
+  #       if some_complex_logic
+  #         record.errors.add :base, 'This record is invalid'
+  #       end
+  #     end
+  #
+  #     private
+  #       def some_complex_logic
+  #         # ...
+  #       end
+  #   end
+  #
+  # 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
+
+ActiveModel::Validations::ClassMethods::VALID_OPTIONS_FOR_VALIDATE: untyped
+
+# = 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 ActiveModel::ValidationError < StandardError
+  attr_reader model: untyped
+
+  def initialize: (untyped model) -> untyped
+end
+
+class ActiveModel::Validations::WithValidator < EachValidator
+  # :nodoc:
+  def validate_each: (untyped record, untyped attr, untyped val) -> untyped
+end
+
+# == Active \Model \Validator
+#
+# A simple base class that can be used along with
+# ActiveModel::Validations::ClassMethods.validates_with
+#
+#   class Person
+#     include ActiveModel::Validations
+#     validates_with MyValidator
+#   end
+#
+#   class MyValidator < ActiveModel::Validator
+#     def validate(record)
+#       if some_complex_logic
+#         record.errors.add(:base, "This record is invalid")
+#       end
+#     end
+#
+#     private
+#       def some_complex_logic
+#         # ...
+#       end
+#   end
+#
+# Any class that inherits from ActiveModel::Validator must implement a method
+# called +validate+ which accepts a +record+.
+#
+#   class Person
+#     include ActiveModel::Validations
+#     validates_with MyValidator
+#   end
+#
+#   class MyValidator < ActiveModel::Validator
+#     def validate(record)
+#       record # => The person instance being validated
+#       options # => Any non-standard options passed to validates_with
+#     end
+#   end
+#
+# To cause a validation error, you must add to the +record+'s errors directly
+# from within the validators message.
+#
+#   class MyValidator < ActiveModel::Validator
+#     def validate(record)
+#       record.errors.add :base, "This is some custom error message"
+#       record.errors.add :first_name, "This is some complex validation"
+#       # etc...
+#     end
+#   end
+#
+# To add behavior to the initialize method, use the following signature:
+#
+#   class MyValidator < ActiveModel::Validator
+#     def initialize(options)
+#       super
+#       @my_custom_field = options[:field_name] || :first_name
+#     end
+#   end
+#
+# Note that the validator is initialized only once for the whole application
+# life cycle, and not on each validation run.
+#
+# The easiest way to add custom validators for validating individual attributes
+# is with the convenient <tt>ActiveModel::EachValidator</tt>.
+#
+#   class TitleValidator < ActiveModel::EachValidator
+#     def validate_each(record, attribute, value)
+#       record.errors.add attribute, 'must be Mr., Mrs., or Dr.' unless %w(Mr. Mrs. Dr.).include?(value)
+#     end
+#   end
+#
+# This can now be used in combination with the +validates+ method
+# (see <tt>ActiveModel::Validations::ClassMethods.validates</tt> for more on this).
+#
+#   class Person
+#     include ActiveModel::Validations
+#     attr_accessor :title
+#
+#     validates :title, presence: true, title: true
+#   end
+#
+# It can be useful to access the class that is using that validator when there are prerequisites such
+# as an +attr_accessor+ being present. This class is accessible via <tt>options[:class]</tt> in the constructor.
+# To setup your validator override the constructor.
+#
+#   class MyValidator < ActiveModel::Validator
+#     def initialize(options={})
+#       super
+#       options[:class].attr_accessor :custom_attribute
+#     end
+#   end
+class ActiveModel::Validator
+  attr_reader options: untyped
+
+  # Returns the kind of the validator.
+  #
+  #   PresenceValidator.kind   # => :presence
+  #   AcceptanceValidator.kind # => :acceptance
+  def self.kind: () -> untyped
+
+  # Accepts options that will be made available through the +options+ reader.
+  def initialize: (?::Hash[untyped, untyped] options) -> untyped
+
+  # Returns the kind for this validator.
+  #
+  #   PresenceValidator.new(attributes: [:username]).kind # => :presence
+  #   AcceptanceValidator.new(attributes: [:terms]).kind  # => :acceptance
+  def kind: () -> untyped
+
+  # Override this method in subclasses with validation logic, adding errors
+  # to the records +errors+ array where necessary.
+  def validate: (untyped record) -> untyped
+end
+
+class ActiveModel::EachValidator < Validator
+  # +EachValidator+ is a validator which iterates through the attributes given
+  # in the options hash invoking the <tt>validate_each</tt> method passing in the
+  # record, attribute and value.
+  #
+  # All \Active \Model validations are built on top of this validator.
+  # nodoc:
+  attr_reader attributes: untyped
+
+  # Returns a new validator instance. All options will be available via the
+  # +options+ reader, however the <tt>:attributes</tt> option will be removed
+  # and instead be made available through the +attributes+ reader.
+  def initialize: (untyped options) -> untyped
+
+  # Performs validation on the supplied record. By default this will call
+  # +validate_each+ to determine validity therefore subclasses should
+  # override +validate_each+ with validation logic.
+  def validate: (untyped record) -> untyped
+
+  # Override this method in subclasses with the validation logic, adding
+  # errors to the records +errors+ array where necessary.
+  def validate_each: (untyped record, untyped attribute, untyped value) -> untyped
+
+  # Hook method that gets called by the initializer allowing verification
+  # that the arguments supplied are valid. You could for example raise an
+  # +ArgumentError+ when invalid options are supplied.
+  def check_validity!: () -> nil
+end
+
+class ActiveModel::BlockValidator < EachValidator
+  # +BlockValidator+ is a special +EachValidator+ which receives a block on initialization
+  # and call this block for each attribute being validated. +validates_each+ uses this validator.
+  # nodoc:
+  def initialize: (untyped options) { () -> untyped } -> untyped
+
+  def validate_each: (untyped record, untyped attribute, untyped value) -> untyped
+end
+