packwerk 1.0.2 → 1.2.0

data/sorbet/rbi/gems/{activerecord@6.1.0.alpha-d80c18a391e33552ae2d943e68af56946f883f65.rbi → activerecord@7.0.0.alpha-d612542336d9a61381311c95a27d801bb4094779.rbi}

@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `activerecord` gem.
-# Please instead update this file by running `dev typecheck update`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
@@ -14,6 +14,9 @@ module ActiveRecord
   end
 end
 
+class ActiveRecord::ActiveJobRequiredError < ::ActiveRecord::ActiveRecordError
+end
+
 class ActiveRecord::ActiveRecordError < ::StandardError
 end
 
@@ -26,23 +29,14 @@ end
 class ActiveRecord::AdapterTimeout < ::ActiveRecord::QueryAborted
 end
 
-class ActiveRecord::AdvisoryLockBase < ::ActiveRecord::Base
-  class << self
-    def _internal?; end
-    def _validators; end
-    def attribute_type_decorations; end
-    def defined_enums; end
-  end
-end
-
 module ActiveRecord::Aggregations
-  def reload(*_); end
+  def reload(*_arg0); end
 
   private
 
   def clear_aggregation_cache; end
   def init_internals; end
-  def initialize_dup(*_); end
+  def initialize_dup(*_arg0); end
 end
 
 module ActiveRecord::Aggregations::ClassMethods
@@ -59,27 +53,37 @@ class ActiveRecord::AmbiguousSourceReflectionForThroughAssociation < ::ActiveRec
 end
 
 class ActiveRecord::AssociationNotFoundError < ::ActiveRecord::ConfigurationError
+  include(::DidYouMean::Correctable)
+
   def initialize(record = T.unsafe(nil), association_name = T.unsafe(nil)); end
+
+  def association_name; end
+  def record; end
+end
+
+class ActiveRecord::AssociationNotFoundError::Correction
+  def initialize(error); end
+
+  def corrections; end
 end
 
 class ActiveRecord::AssociationRelation < ::ActiveRecord::Relation
-  def initialize(klass, association, **_); end
+  def initialize(klass, association, **_arg2); end
 
   def ==(other); end
-  def build(attributes = T.unsafe(nil), &block); end
-  def create(attributes = T.unsafe(nil), &block); end
-  def create!(attributes = T.unsafe(nil), &block); end
   def insert(attributes, **kwargs); end
   def insert!(attributes, **kwargs); end
   def insert_all(attributes, **kwargs); end
   def insert_all!(attributes, **kwargs); end
-  def new(attributes = T.unsafe(nil), &block); end
   def proxy_association; end
   def upsert(attributes, **kwargs); end
   def upsert_all(attributes, **kwargs); end
 
   private
 
+  def _create(attributes, &block); end
+  def _create!(attributes, &block); end
+  def _new(attributes, &block); end
   def exec_queries; end
 end
 
@@ -94,7 +98,7 @@ module ActiveRecord::Associations
 
   def association(name); end
   def association_cached?(name); end
-  def reload(*_); end
+  def reload(*_arg0); end
 
   private
 
@@ -102,7 +106,7 @@ module ActiveRecord::Associations
   def association_instance_set(name, association); end
   def clear_association_cache; end
   def init_internals; end
-  def initialize_dup(*_); end
+  def initialize_dup(*_arg0); end
 
   class << self
     def eager_load!; end
@@ -112,7 +116,7 @@ end
 class ActiveRecord::Associations::AliasTracker
   def initialize(connection, aliases); end
 
-  def aliased_table_for(table_name, aliased_name, type_caster); end
+  def aliased_table_for(arel_table, table_name = T.unsafe(nil)); end
   def aliases; end
 
   private
@@ -120,7 +124,7 @@ class ActiveRecord::Associations::AliasTracker
   def truncate(name); end
 
   class << self
-    def create(connection, initial_table, joins); end
+    def create(connection, initial_table, joins, aliases = T.unsafe(nil)); end
     def initial_count_for(connection, name, table_joins); end
   end
 end
@@ -140,7 +144,7 @@ class ActiveRecord::Associations::Association
   def loaded?; end
   def marshal_dump; end
   def marshal_load(data); end
-  def options(*args, &block); end
+  def options(*_arg0, &_arg1); end
   def owner; end
   def reflection; end
   def reload(force = T.unsafe(nil)); end
@@ -159,20 +163,22 @@ class ActiveRecord::Associations::Association
 
   def association_scope; end
   def build_record(attributes); end
-  def creation_attributes; end
+  def enqueue_destroy_association(options); end
   def find_target; end
   def find_target?; end
   def foreign_key_for?(record); end
   def foreign_key_present?; end
+  def inversable?(record); end
   def inverse_association_for(record); end
   def inverse_reflection_for(record); end
   def invertible_for?(record); end
+  def matches_foreign_key?(record); end
   def raise_on_type_mismatch!(record); end
   def scope_for_create; end
-  def set_owner_attributes(record); end
   def skip_statement_cache?(scope); end
   def stale_state; end
   def target_scope; end
+  def violates_strict_loading?; end
 end
 
 class ActiveRecord::Associations::AssociationScope
@@ -226,7 +232,7 @@ class ActiveRecord::Associations::BelongsToAssociation < ::ActiveRecord::Associa
   def invertible_for?(record); end
   def primary_key(klass); end
   def replace(record); end
-  def replace_keys(record); end
+  def replace_keys(record, force: T.unsafe(nil)); end
   def require_counter_update?; end
   def stale_state; end
   def update_counters(by); end
@@ -241,7 +247,7 @@ class ActiveRecord::Associations::BelongsToPolymorphicAssociation < ::ActiveReco
 
   def inverse_reflection_for(record); end
   def raise_on_type_mismatch!(record); end
-  def replace_keys(record); end
+  def replace_keys(record, force: T.unsafe(nil)); end
   def stale_state; end
 end
 
@@ -253,13 +259,14 @@ class ActiveRecord::Associations::Builder::Association
     def build(model, name, scope, options, &block); end
     def create_reflection(model, name, scope, options, &block); end
     def extensions; end
-    def extensions=(_); end
+    def extensions=(_arg0); end
 
     private
 
+    def add_after_commit_jobs_callback(model, dependent); end
     def add_destroy_callbacks(model, reflection); end
     def build_scope(scope); end
-    def check_dependent_options(dependent); end
+    def check_dependent_options(dependent, model); end
     def define_accessors(model, reflection); end
     def define_callbacks(model, reflection); end
     def define_extensions(model, name); end
@@ -392,7 +399,6 @@ class ActiveRecord::Associations::CollectionAssociation < ::ActiveRecord::Associ
   def scope; end
   def size; end
   def target=(record); end
-  def transaction(*args); end
   def writer(records); end
 
   private
@@ -411,172 +417,183 @@ class ActiveRecord::Associations::CollectionAssociation < ::ActiveRecord::Associ
   def replace_common_records_in_memory(new_target, original_target); end
   def replace_on_target(record, index, skip_callbacks); end
   def replace_records(new_target, original_target); end
+  def transaction(&block); end
 end
 
 class ActiveRecord::Associations::CollectionProxy < ::ActiveRecord::Relation
-  def initialize(klass, association, **_); end
+  def initialize(klass, association, **_arg2); end
 
   def <<(*records); end
   def ==(other); end
-  def _select!(*args, &block); end
-  def annotate(*args, &block); end
-  def annotate!(*args, &block); end
-  def annotate_values(*args, &block); end
+  def _select!(*_arg0, &_arg1); end
+  def and(*_arg0, &_arg1); end
+  def and!(*_arg0, &_arg1); end
+  def annotate(*_arg0, &_arg1); end
+  def annotate!(*_arg0, &_arg1); end
+  def annotate_values(*_arg0, &_arg1); end
   def annotate_values=(arg); end
   def append(*records); end
-  def arel(*args, &block); end
+  def arel(*_arg0, &_arg1); end
   def build(attributes = T.unsafe(nil), &block); end
   def calculate(operation, column_name); end
   def clear; end
   def concat(*records); end
-  def construct_join_dependency(*args, &block); end
+  def construct_join_dependency(*_arg0, &_arg1); end
   def create(attributes = T.unsafe(nil), &block); end
   def create!(attributes = T.unsafe(nil), &block); end
-  def create_with(*args, &block); end
-  def create_with!(*args, &block); end
-  def create_with_value(*args, &block); end
+  def create_with(*_arg0, &_arg1); end
+  def create_with!(*_arg0, &_arg1); end
+  def create_with_value(*_arg0, &_arg1); end
   def create_with_value=(arg); end
   def delete(*records); end
   def delete_all(dependent = T.unsafe(nil)); end
   def destroy(*records); end
   def destroy_all; end
-  def distinct(*args, &block); end
-  def distinct!(*args, &block); end
-  def distinct_value(*args, &block); end
+  def distinct(*_arg0, &_arg1); end
+  def distinct!(*_arg0, &_arg1); end
+  def distinct_value(*_arg0, &_arg1); end
   def distinct_value=(arg); end
-  def eager_load(*args, &block); end
-  def eager_load!(*args, &block); end
-  def eager_load_values(*args, &block); end
+  def eager_load(*_arg0, &_arg1); end
+  def eager_load!(*_arg0, &_arg1); end
+  def eager_load_values(*_arg0, &_arg1); end
   def eager_load_values=(arg); end
   def empty?; end
-  def except(*args, &block); end
-  def extending(*args, &block); end
-  def extending!(*args, &block); end
-  def extending_values(*args, &block); end
+  def except(*_arg0, &_arg1); end
+  def excluding(*_arg0, &_arg1); end
+  def excluding!(*_arg0, &_arg1); end
+  def extending(*_arg0, &_arg1); end
+  def extending!(*_arg0, &_arg1); end
+  def extending_values(*_arg0, &_arg1); end
   def extending_values=(arg); end
-  def extensions(*args, &block); end
-  def extract_associated(*args, &block); end
+  def extensions(*_arg0, &_arg1); end
+  def extract_associated(*_arg0, &_arg1); end
   def find(*args); end
-  def from(*args, &block); end
-  def from!(*args, &block); end
-  def from_clause(*args, &block); end
+  def from(*_arg0, &_arg1); end
+  def from!(*_arg0, &_arg1); end
+  def from_clause(*_arg0, &_arg1); end
   def from_clause=(arg); end
-  def group(*args, &block); end
-  def group!(*args, &block); end
-  def group_values(*args, &block); end
+  def group(*_arg0, &_arg1); end
+  def group!(*_arg0, &_arg1); end
+  def group_values(*_arg0, &_arg1); end
   def group_values=(arg); end
-  def having(*args, &block); end
-  def having!(*args, &block); end
-  def having_clause(*args, &block); end
+  def having(*_arg0, &_arg1); end
+  def having!(*_arg0, &_arg1); end
+  def having_clause(*_arg0, &_arg1); end
   def having_clause=(arg); end
   def include?(record); end
-  def includes(*args, &block); end
-  def includes!(*args, &block); end
-  def includes_values(*args, &block); end
+  def includes(*_arg0, &_arg1); end
+  def includes!(*_arg0, &_arg1); end
+  def includes_values(*_arg0, &_arg1); end
   def includes_values=(arg); end
-  def insert(*args, &block); end
-  def insert!(*args, &block); end
-  def insert_all(*args, &block); end
-  def insert_all!(*args, &block); end
-  def joins(*args, &block); end
-  def joins!(*args, &block); end
-  def joins_values(*args, &block); end
+  def insert(*_arg0, &_arg1); end
+  def insert!(*_arg0, &_arg1); end
+  def insert_all(*_arg0, &_arg1); end
+  def insert_all!(*_arg0, &_arg1); end
+  def inspect; end
+  def invert_where(*_arg0, &_arg1); end
+  def invert_where!(*_arg0, &_arg1); end
+  def joins(*_arg0, &_arg1); end
+  def joins!(*_arg0, &_arg1); end
+  def joins_values(*_arg0, &_arg1); end
   def joins_values=(arg); end
   def last(limit = T.unsafe(nil)); end
-  def left_joins(*args, &block); end
-  def left_outer_joins(*args, &block); end
-  def left_outer_joins!(*args, &block); end
-  def left_outer_joins_values(*args, &block); end
+  def left_joins(*_arg0, &_arg1); end
+  def left_outer_joins(*_arg0, &_arg1); end
+  def left_outer_joins!(*_arg0, &_arg1); end
+  def left_outer_joins_values(*_arg0, &_arg1); end
   def left_outer_joins_values=(arg); end
-  def limit(*args, &block); end
-  def limit!(*args, &block); end
-  def limit_value(*args, &block); end
+  def limit(*_arg0, &_arg1); end
+  def limit!(*_arg0, &_arg1); end
+  def limit_value(*_arg0, &_arg1); end
   def limit_value=(arg); end
   def load_target; end
+  def loaded; end
   def loaded?; end
-  def lock(*args, &block); end
-  def lock!(*args, &block); end
-  def lock_value(*args, &block); end
+  def lock(*_arg0, &_arg1); end
+  def lock!(*_arg0, &_arg1); end
+  def lock_value(*_arg0, &_arg1); end
   def lock_value=(arg); end
-  def merge(*args, &block); end
-  def merge!(*args, &block); end
+  def merge(*_arg0, &_arg1); end
+  def merge!(*_arg0, &_arg1); end
   def new(attributes = T.unsafe(nil), &block); end
-  def none(*args, &block); end
-  def none!(*args, &block); end
-  def offset(*args, &block); end
-  def offset!(*args, &block); end
-  def offset_value(*args, &block); end
+  def none(*_arg0, &_arg1); end
+  def none!(*_arg0, &_arg1); end
+  def offset(*_arg0, &_arg1); end
+  def offset!(*_arg0, &_arg1); end
+  def offset_value(*_arg0, &_arg1); end
   def offset_value=(arg); end
-  def only(*args, &block); end
-  def optimizer_hints(*args, &block); end
-  def optimizer_hints!(*args, &block); end
-  def optimizer_hints_values(*args, &block); end
+  def only(*_arg0, &_arg1); end
+  def optimizer_hints(*_arg0, &_arg1); end
+  def optimizer_hints!(*_arg0, &_arg1); end
+  def optimizer_hints_values(*_arg0, &_arg1); end
   def optimizer_hints_values=(arg); end
-  def or(*args, &block); end
-  def or!(*args, &block); end
-  def order(*args, &block); end
-  def order!(*args, &block); end
-  def order_values(*args, &block); end
+  def or(*_arg0, &_arg1); end
+  def or!(*_arg0, &_arg1); end
+  def order(*_arg0, &_arg1); end
+  def order!(*_arg0, &_arg1); end
+  def order_values(*_arg0, &_arg1); end
   def order_values=(arg); end
   def pluck(*column_names); end
-  def preload(*args, &block); end
-  def preload!(*args, &block); end
-  def preload_values(*args, &block); end
+  def preload(*_arg0, &_arg1); end
+  def preload!(*_arg0, &_arg1); end
+  def preload_values(*_arg0, &_arg1); end
   def preload_values=(arg); end
   def prepend(*args); end
   def proxy_association; end
   def push(*records); end
-  def readonly(*args, &block); end
-  def readonly!(*args, &block); end
-  def readonly_value(*args, &block); end
+  def readonly(*_arg0, &_arg1); end
+  def readonly!(*_arg0, &_arg1); end
+  def readonly_value(*_arg0, &_arg1); end
   def readonly_value=(arg); end
   def records; end
-  def references(*args, &block); end
-  def references!(*args, &block); end
-  def references_values(*args, &block); end
+  def references(*_arg0, &_arg1); end
+  def references!(*_arg0, &_arg1); end
+  def references_values(*_arg0, &_arg1); end
   def references_values=(arg); end
   def reload; end
-  def reorder(*args, &block); end
-  def reorder!(*args, &block); end
-  def reordering_value(*args, &block); end
+  def reorder(*_arg0, &_arg1); end
+  def reorder!(*_arg0, &_arg1); end
+  def reordering_value(*_arg0, &_arg1); end
   def reordering_value=(arg); end
   def replace(other_array); end
-  def reselect(*args, &block); end
-  def reselect!(*args, &block); end
+  def reselect(*_arg0, &_arg1); end
+  def reselect!(*_arg0, &_arg1); end
   def reset; end
   def reset_scope; end
-  def reverse_order(*args, &block); end
-  def reverse_order!(*args, &block); end
-  def reverse_order_value(*args, &block); end
+  def reverse_order(*_arg0, &_arg1); end
+  def reverse_order!(*_arg0, &_arg1); end
+  def reverse_order_value(*_arg0, &_arg1); end
   def reverse_order_value=(arg); end
-  def rewhere(*args, &block); end
+  def rewhere(*_arg0, &_arg1); end
   def scope; end
-  def scoping(*args, &block); end
-  def select_values(*args, &block); end
+  def scoping(*_arg0, &_arg1); end
+  def select_values(*_arg0, &_arg1); end
   def select_values=(arg); end
   def size; end
-  def skip_preloading!(*args, &block); end
-  def skip_query_cache!(*args, &block); end
-  def skip_query_cache_value(*args, &block); end
+  def skip_preloading!(*_arg0, &_arg1); end
+  def skip_query_cache!(*_arg0, &_arg1); end
+  def skip_query_cache_value(*_arg0, &_arg1); end
   def skip_query_cache_value=(arg); end
-  def spawn(*args, &block); end
-  def strict_loading(*args, &block); end
-  def strict_loading!(*args, &block); end
-  def strict_loading_value(*args, &block); end
+  def spawn(*_arg0, &_arg1); end
+  def strict_loading(*_arg0, &_arg1); end
+  def strict_loading!(*_arg0, &_arg1); end
+  def strict_loading_value(*_arg0, &_arg1); end
   def strict_loading_value=(arg); end
   def take(limit = T.unsafe(nil)); end
   def target; end
-  def unscope(*args, &block); end
-  def unscope!(*args, &block); end
-  def unscope_values(*args, &block); end
+  def uniq!(*_arg0, &_arg1); end
+  def unscope(*_arg0, &_arg1); end
+  def unscope!(*_arg0, &_arg1); end
+  def unscope_values(*_arg0, &_arg1); end
   def unscope_values=(arg); end
-  def upsert(*args, &block); end
-  def upsert_all(*args, &block); end
-  def values(*args, &block); end
-  def where(*args, &block); end
-  def where!(*args, &block); end
-  def where_clause(*args, &block); end
+  def upsert(*_arg0, &_arg1); end
+  def upsert_all(*_arg0, &_arg1); end
+  def values(*_arg0, &_arg1); end
+  def where(*_arg0, &_arg1); end
+  def where!(*_arg0, &_arg1); end
+  def where_clause(*_arg0, &_arg1); end
   def where_clause=(arg); end
+  def without(*_arg0, &_arg1); end
 
   private
 
@@ -590,6 +607,10 @@ end
 module ActiveRecord::Associations::ForeignAssociation
   def foreign_key_present?; end
   def nullified_owner_attributes; end
+
+  private
+
+  def set_owner_attributes(record); end
 end
 
 class ActiveRecord::Associations::HasManyAssociation < ::ActiveRecord::Associations::CollectionAssociation
@@ -600,8 +621,8 @@ class ActiveRecord::Associations::HasManyAssociation < ::ActiveRecord::Associati
 
   private
 
-  def _create_record(attributes, *_); end
-  def concat_records(records, *_); end
+  def _create_record(attributes, *_arg1); end
+  def concat_records(records, *_arg1); end
   def count_records; end
   def delete_count(method, scope); end
   def delete_or_nullify_all_records(method); end
@@ -639,6 +660,7 @@ class ActiveRecord::Associations::HasManyThroughAssociation < ::ActiveRecord::As
   def save_through_record(record); end
   def target_reflection_has_associated_record?; end
   def through_records_for(record); end
+  def through_scope; end
   def through_scope_attributes; end
   def update_through_counter?(method); end
 end
@@ -674,8 +696,9 @@ class ActiveRecord::Associations::JoinDependency
 
   def apply_column_aliases(relation); end
   def base_klass; end
+  def each(&block); end
   def instantiate(result_set, strict_loading_value, &block); end
-  def join_constraints(joins_to_add, alias_tracker); end
+  def join_constraints(joins_to_add, alias_tracker, references); end
   def reflections; end
 
   protected
@@ -690,13 +713,10 @@ class ActiveRecord::Associations::JoinDependency
   def build(associations, base_klass); end
   def construct(ar_parent, parent, row, seen, model_cache, strict_loading_value); end
   def construct_model(record, node, row, model_cache, id, strict_loading_value); end
-  def construct_tables!(join_root); end
-  def explicit_selections(root_column_aliases, result_set); end
   def find_reflection(klass, name); end
+  def join_root_alias; end
   def make_constraints(parent, child, join_type); end
   def make_join_constraints(join_root, join_type); end
-  def table_alias_for(reflection, parent, join); end
-  def table_aliases_for(parent, node); end
   def walk(left, right, join_type); end
 
   class << self
@@ -720,10 +740,10 @@ class ActiveRecord::Associations::JoinDependency::Aliases::Column < ::Struct
   def name=(_); end
 
   class << self
-    def [](*_); end
+    def [](*_arg0); end
     def inspect; end
     def members; end
-    def new(*_); end
+    def new(*_arg0); end
   end
 end
 
@@ -735,10 +755,10 @@ class ActiveRecord::Associations::JoinDependency::Aliases::Table < ::Struct
   def node=(_); end
 
   class << self
-    def [](*_); end
+    def [](*_arg0); end
     def inspect; end
     def members; end
-    def new(*_); end
+    def new(*_arg0); end
   end
 end
 
@@ -751,9 +771,8 @@ class ActiveRecord::Associations::JoinDependency::JoinAssociation < ::ActiveReco
   def reflection; end
   def strict_loading?; end
   def table; end
-  def table=(_); end
+  def table=(_arg0); end
   def tables; end
-  def tables=(tables); end
 
   private
 
@@ -770,66 +789,106 @@ end
 class ActiveRecord::Associations::Preloader
   extend(::ActiveSupport::Autoload)
 
-  def preload(records, associations, preload_scope = T.unsafe(nil)); end
-
-  private
-
-  def grouped_records(association, records, polymorphic_parent); end
-  def preloader_for(reflection, owners); end
-  def preloaders_for_hash(association, records, scope, polymorphic_parent); end
-  def preloaders_for_one(association, records, scope, polymorphic_parent); end
-  def preloaders_for_reflection(reflection, records, scope); end
-  def preloaders_on(association, records, scope, polymorphic_parent = T.unsafe(nil)); end
-end
-
-class ActiveRecord::Associations::Preloader::AlreadyLoaded
-  def initialize(klass, owners, reflection, preload_scope); end
-
-  def preloaded_records; end
-  def records_by_owner; end
-  def run; end
-
-  private
+  def initialize(associate_by_default: T.unsafe(nil), **kwargs); end
 
-  def owners; end
-  def reflection; end
+  def associate_by_default; end
+  def associations; end
+  def branches; end
+  def call; end
+  def empty?; end
+  def loaders; end
+  def preload(records, associations, preload_scope = T.unsafe(nil)); end
+  def records; end
+  def scope; end
 end
 
 class ActiveRecord::Associations::Preloader::Association
-  def initialize(klass, owners, reflection, preload_scope); end
+  def initialize(klass, owners, reflection, preload_scope, associate_by_default = T.unsafe(nil)); end
 
+  def already_loaded?; end
+  def association_key_name; end
+  def ensure_loaded; end
+  def load_records(raw_records = T.unsafe(nil)); end
+  def loader_query; end
+  def owner_keys; end
   def preloaded_records; end
   def records_by_owner; end
   def run; end
+  def run?; end
+  def runnable_loaders; end
+  def scope; end
+  def set_inverse(record); end
 
   private
 
   def associate_records_to_owner(owner, records); end
-  def association_key_name; end
   def association_key_type; end
   def build_scope; end
   def convert_key(key); end
+  def fetch_from_preloaded_records; end
   def key_conversion_required?; end
   def klass; end
-  def load_records; end
   def model; end
   def owner_key_name; end
   def owner_key_type; end
-  def owner_keys; end
   def owners; end
   def owners_by_key; end
   def preload_scope; end
-  def records_for(ids); end
   def reflection; end
   def reflection_scope; end
+end
+
+class ActiveRecord::Associations::Preloader::Association::LoaderQuery
+  def initialize(scope, association_key_name); end
+
+  def association_key_name; end
+  def eql?(other); end
+  def hash; end
+  def load_records_in_batch(loaders); end
+  def records_for(loaders); end
   def scope; end
 end
 
-class ActiveRecord::Associations::Preloader::ThroughAssociation < ::ActiveRecord::Associations::Preloader::Association
-  def initialize(*_); end
+class ActiveRecord::Associations::Preloader::Batch
+  def initialize(preloaders); end
+
+  def call; end
+
+  private
+
+  def group_and_load_similar(loaders); end
+  def loaders; end
+end
+
+class ActiveRecord::Associations::Preloader::Branch
+  def initialize(association:, children:, parent:, associate_by_default:, scope:); end
+
+  def associate_by_default; end
+  def association; end
+  def children; end
+  def done?; end
+  def grouped_records; end
+  def loaders; end
+  def parent; end
+  def polymorphic?; end
+  def preloaded_records; end
+  def preloaded_records=(_arg0); end
+  def preloaders_for_reflection(reflection, reflection_records); end
+  def root?; end
+  def runnable_loaders; end
+  def scope; end
+  def source_records; end
 
+  private
+
+  def build_children(children); end
+  def preloader_for(reflection); end
+end
+
+class ActiveRecord::Associations::Preloader::ThroughAssociation < ::ActiveRecord::Associations::Preloader::Association
   def preloaded_records; end
   def records_by_owner; end
+  def runnable_loaders; end
 
   private
 
@@ -842,8 +901,6 @@ class ActiveRecord::Associations::Preloader::ThroughAssociation < ::ActiveRecord
   def through_scope; end
 end
 
-ActiveRecord::Associations::Preloader::ThroughAssociation::PRELOADER = T.let(T.unsafe(nil), ActiveRecord::Associations::Preloader)
-
 class ActiveRecord::Associations::SingularAssociation < ::ActiveRecord::Associations::Association
   def build(attributes = T.unsafe(nil), &block); end
   def force_reload_reader; end
@@ -860,7 +917,7 @@ class ActiveRecord::Associations::SingularAssociation < ::ActiveRecord::Associat
 end
 
 module ActiveRecord::Associations::ThroughAssociation
-  def source_reflection(*args, &block); end
+  def source_reflection(*_arg0, &_arg1); end
 
   private
 
@@ -875,6 +932,36 @@ module ActiveRecord::Associations::ThroughAssociation
   def through_reflection; end
 end
 
+class ActiveRecord::AsynchronousQueriesTracker
+  def initialize; end
+
+  def current_session; end
+  def finalize_session; end
+  def start_session; end
+
+  class << self
+    def complete(asynchronous_queries_tracker); end
+    def install_executor_hooks(executor = T.unsafe(nil)); end
+    def run; end
+  end
+end
+
+module ActiveRecord::AsynchronousQueriesTracker::NullSession
+  class << self
+    def active?; end
+  end
+end
+
+class ActiveRecord::AsynchronousQueriesTracker::Session
+  def initialize; end
+
+  def active?; end
+  def finalize; end
+end
+
+class ActiveRecord::AsynchronousQueryInsideTransactionError < ::ActiveRecord::ActiveRecordError
+end
+
 module ActiveRecord::AttributeAssignment
   include(::ActiveModel::ForbiddenAttributesProtection)
   include(::ActiveModel::AttributeAssignment)
@@ -898,34 +985,6 @@ class ActiveRecord::AttributeAssignmentError < ::ActiveRecord::ActiveRecordError
   def exception; end
 end
 
-module ActiveRecord::AttributeDecorators
-  extend(::ActiveSupport::Concern)
-
-  mixes_in_class_methods(::ActiveRecord::AttributeDecorators::ClassMethods)
-end
-
-module ActiveRecord::AttributeDecorators::ClassMethods
-  def decorate_attribute_type(column_name, decorator_name, &block); end
-  def decorate_matching_attribute_types(matcher, decorator_name, &block); end
-
-  private
-
-  def load_schema!; end
-end
-
-class ActiveRecord::AttributeDecorators::TypeDecorator
-  def initialize(decorations = T.unsafe(nil)); end
-
-  def apply(name, type); end
-  def clear(*args, &block); end
-  def merge(*args); end
-
-  private
-
-  def decorators_for(name, type); end
-  def matching(name, type); end
-end
-
 module ActiveRecord::AttributeMethods
   extend(::ActiveSupport::Concern)
   extend(::ActiveSupport::Autoload)
@@ -945,10 +1004,11 @@ module ActiveRecord::AttributeMethods
 
   def [](attr_name); end
   def []=(attr_name, value); end
+  def _has_attribute?(attr_name); end
   def accessed_fields; end
   def attribute_for_inspect(attr_name); end
   def attribute_names; end
-  def attribute_present?(attribute); end
+  def attribute_present?(attr_name); end
   def attributes; end
   def has_attribute?(attr_name); end
   def respond_to?(name, include_private = T.unsafe(nil)); end
@@ -959,8 +1019,12 @@ module ActiveRecord::AttributeMethods
   def attributes_for_create(attribute_names); end
   def attributes_for_update(attribute_names); end
   def attributes_with_values(attribute_names); end
-  def format_for_inspect(value); end
+  def format_for_inspect(name, value); end
   def pk_attribute?(name); end
+
+  class << self
+    def dangerous_attribute_methods; end
+  end
 end
 
 module ActiveRecord::AttributeMethods::BeforeTypeCast
@@ -971,14 +1035,15 @@ module ActiveRecord::AttributeMethods::BeforeTypeCast
 
   private
 
-  def attribute_before_type_cast(attribute_name); end
-  def attribute_came_from_user?(attribute_name); end
+  def attribute_before_type_cast(attr_name); end
+  def attribute_came_from_user?(attr_name); end
+  def attribute_for_database(attr_name); end
 end
 
 module ActiveRecord::AttributeMethods::ClassMethods
+  def _has_attribute?(attr_name); end
   def attribute_method?(attribute); end
   def attribute_names; end
-  def column_for_attribute(name); end
   def dangerous_attribute_method?(name); end
   def dangerous_class_method?(method_name); end
   def define_attribute_methods; end
@@ -1003,7 +1068,7 @@ module ActiveRecord::AttributeMethods::Dirty
   def changed_attribute_names_to_save; end
   def changes_to_save; end
   def has_changes_to_save?; end
-  def reload(*_); end
+  def reload(*_arg0); end
   def saved_change_to_attribute(attr_name); end
   def saved_change_to_attribute?(attr_name, **options); end
   def saved_changes; end
@@ -1016,9 +1081,6 @@ module ActiveRecord::AttributeMethods::Dirty
   def _touch_row(attribute_names, time); end
   def _update_record(attribute_names = T.unsafe(nil)); end
   def attribute_names_for_partial_writes; end
-  def mutations_before_last_save; end
-  def mutations_from_database; end
-  def write_attribute_without_type_cast(attr_name, value); end
 end
 
 class ActiveRecord::AttributeMethods::GeneratedAttributeMethods < ::Module
@@ -1040,6 +1102,7 @@ module ActiveRecord::AttributeMethods::PrimaryKey
   def id=(value); end
   def id?; end
   def id_before_type_cast; end
+  def id_for_database; end
   def id_in_database; end
   def id_was; end
   def to_key; end
@@ -1072,7 +1135,7 @@ module ActiveRecord::AttributeMethods::Query
 
   private
 
-  def attribute?(attribute_name); end
+  def attribute?(attr_name); end
 end
 
 ActiveRecord::AttributeMethods::RESTRICTED_CLASS_METHODS = T.let(T.unsafe(nil), Array)
@@ -1104,7 +1167,7 @@ module ActiveRecord::AttributeMethods::Serialization
 end
 
 module ActiveRecord::AttributeMethods::Serialization::ClassMethods
-  def serialize(attr_name, class_name_or_coder = T.unsafe(nil)); end
+  def serialize(attr_name, class_name_or_coder = T.unsafe(nil), **options); end
 
   private
 
@@ -1122,11 +1185,11 @@ module ActiveRecord::AttributeMethods::TimeZoneConversion
 end
 
 module ActiveRecord::AttributeMethods::TimeZoneConversion::ClassMethods
+  def define_attribute(name, cast_type, **_arg2); end
 
   private
 
   def create_time_zone_conversion_attribute?(name, cast_type); end
-  def inherited(subclass); end
 end
 
 class ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
@@ -1138,6 +1201,10 @@ class ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
   def convert_time_to_time_zone(value); end
   def map_avoiding_infinite_recursion(value); end
   def set_time_zone_without_conversion(value); end
+
+  class << self
+    def new(subtype); end
+  end
 end
 
 module ActiveRecord::AttributeMethods::Write
@@ -1150,8 +1217,7 @@ module ActiveRecord::AttributeMethods::Write
 
   private
 
-  def attribute=(attribute_name, value); end
-  def write_attribute_without_type_cast(attr_name, value); end
+  def attribute=(attr_name, value); end
 end
 
 module ActiveRecord::AttributeMethods::Write::ClassMethods
@@ -1168,7 +1234,7 @@ module ActiveRecord::Attributes
 end
 
 module ActiveRecord::Attributes::ClassMethods
-  def attribute(name, cast_type = T.unsafe(nil), **options); end
+  def attribute(name, cast_type = T.unsafe(nil), default: T.unsafe(nil), **options); end
   def define_attribute(name, cast_type, default: T.unsafe(nil), user_provided_default: T.unsafe(nil)); end
   def load_schema!; end
 
@@ -1192,11 +1258,10 @@ module ActiveRecord::AutosaveAssociation
   private
 
   def _ensure_no_duplicate_errors; end
-  def after_save_collection_association; end
+  def around_save_collection_association; end
   def associated_records_to_validate_or_save(association, new_record, autosave); end
   def association_foreign_key_changed?(reflection, record, key); end
   def association_valid?(reflection, record, index = T.unsafe(nil)); end
-  def before_save_collection_association; end
   def custom_validation_context?; end
   def nested_records_changed_for_autosave?; end
   def normalize_reflection_attribute(indexed_attribute, reflection, index, attribute); end
@@ -1245,7 +1310,6 @@ class ActiveRecord::Base
   include(::ActiveRecord::Validations)
   include(::ActiveRecord::CounterCache)
   include(::ActiveRecord::Attributes)
-  include(::ActiveRecord::AttributeDecorators)
   include(::ActiveRecord::Locking::Optimistic)
   include(::ActiveRecord::Locking::Pessimistic)
   include(::ActiveModel::AttributeMethods)
@@ -1275,6 +1339,7 @@ class ActiveRecord::Base
   include(::ActiveRecord::Serialization)
   include(::ActiveRecord::Store)
   include(::ActiveRecord::SecureToken)
+  include(::ActiveRecord::SignedId)
   include(::ActiveRecord::Suppressor)
   extend(::ActiveModel::Naming)
   extend(::ActiveSupport::Benchmarkable)
@@ -1285,6 +1350,7 @@ class ActiveRecord::Base
   extend(::ActiveModel::Translation)
   extend(::ActiveRecord::Translation)
   extend(::ActiveRecord::DynamicMatchers)
+  extend(::ActiveRecord::DelegatedType)
   extend(::ActiveRecord::Explain)
   extend(::ActiveRecord::Enum)
   extend(::ActiveRecord::Delegation::DelegateCache)
@@ -1307,7 +1373,6 @@ class ActiveRecord::Base
   extend(::ActiveRecord::Validations::ClassMethods)
   extend(::ActiveRecord::CounterCache::ClassMethods)
   extend(::ActiveRecord::Attributes::ClassMethods)
-  extend(::ActiveRecord::AttributeDecorators::ClassMethods)
   extend(::ActiveRecord::Locking::Optimistic::ClassMethods)
   extend(::ActiveModel::AttributeMethods::ClassMethods)
   extend(::ActiveRecord::AttributeMethods::ClassMethods)
@@ -1328,6 +1393,7 @@ class ActiveRecord::Base
   extend(::ActiveRecord::Reflection::ClassMethods)
   extend(::ActiveRecord::Store::ClassMethods)
   extend(::ActiveRecord::SecureToken::ClassMethods)
+  extend(::ActiveRecord::SignedId::ClassMethods)
   extend(::ActiveRecord::Suppressor::ClassMethods)
 
   def __callbacks; end
@@ -1362,7 +1428,6 @@ class ActiveRecord::Base
   def _validators?; end
   def aggregate_reflections; end
   def aggregate_reflections?; end
-  def allow_unsafe_raw_sql; end
   def attribute_aliases; end
   def attribute_aliases?; end
   def attribute_method_matchers; end
@@ -1373,26 +1438,30 @@ class ActiveRecord::Base
   def cache_versioning?; end
   def collection_cache_versioning; end
   def collection_cache_versioning?; end
-  def column_for_attribute(*args, &block); end
+  def column_for_attribute(*_arg0, &_arg1); end
   def default_connection_handler; end
   def default_connection_handler?; end
-  def default_pool_key; end
-  def default_pool_key?; end
+  def default_role; end
+  def default_role?; end
   def default_scope_override; end
   def default_scopes; end
+  def default_shard; end
+  def default_shard?; end
   def default_timezone; end
   def defined_enums; end
   def defined_enums?; end
+  def destroy_association_async_job; end
   def dump_schema_after_migration; end
   def dump_schemas; end
   def error_on_ignored_order; end
   def include_root_in_json; end
   def include_root_in_json?; end
   def index_nested_attribute_errors; end
+  def legacy_connection_handling; end
   def lock_optimistically; end
   def lock_optimistically?; end
   def logger; end
-  def model_name(*args, &block); end
+  def model_name(*_arg0, &_arg1); end
   def nested_attributes_options; end
   def nested_attributes_options?; end
   def partial_writes; end
@@ -1401,13 +1470,20 @@ class ActiveRecord::Base
   def pluralize_table_names?; end
   def primary_key_prefix_type; end
   def record_timestamps; end
-  def record_timestamps=(_); end
+  def record_timestamps=(_arg0); end
   def record_timestamps?; end
   def schema_format; end
+  def signed_id_verifier_secret; end
   def skip_time_zone_conversion_for_attributes; end
   def skip_time_zone_conversion_for_attributes?; end
+  def store_full_class_name; end
+  def store_full_class_name?; end
   def store_full_sti_class; end
   def store_full_sti_class?; end
+  def strict_loading_mode; end
+  def strict_loading_mode=(_arg0); end
+  def strict_loading_mode?; end
+  def suppress_multiple_database_warning; end
   def table_name_prefix; end
   def table_name_prefix?; end
   def table_name_suffix; end
@@ -1416,14 +1492,14 @@ class ActiveRecord::Base
   def time_zone_aware_types; end
   def time_zone_aware_types?; end
   def timestamped_migrations; end
-  def type_for_attribute(*args, &block); end
+  def type_for_attribute(*_arg0, &_arg1); end
   def validation_context; end
   def verbose_query_logs; end
   def warn_on_records_fetched_greater_than; end
 
   private
 
-  def validation_context=(_); end
+  def validation_context=(_arg0); end
 
   class << self
     def __callbacks; end
@@ -1462,6 +1538,8 @@ class ActiveRecord::Base
     def _validators; end
     def _validators=(value); end
     def _validators?; end
+    def action_on_strict_loading_violation; end
+    def action_on_strict_loading_violation=(val); end
     def after_create(*args, **options, &block); end
     def after_destroy(*args, **options, &block); end
     def after_find(*args, **options, &block); end
@@ -1473,20 +1551,24 @@ class ActiveRecord::Base
     def aggregate_reflections=(value); end
     def aggregate_reflections?; end
     def allow_unsafe_raw_sql; end
-    def allow_unsafe_raw_sql=(val); end
+    def allow_unsafe_raw_sql=(value); end
+    def application_record_class; end
+    def application_record_class=(val); end
+    def application_record_class?; end
     def around_create(*args, **options, &block); end
     def around_destroy(*args, **options, &block); end
     def around_save(*args, **options, &block); end
     def around_update(*args, **options, &block); end
+    def async_query_executor; end
+    def async_query_executor=(val); end
+    def asynchronous_queries_session; end
+    def asynchronous_queries_tracker; end
     def attribute_aliases; end
     def attribute_aliases=(value); end
     def attribute_aliases?; end
     def attribute_method_matchers; end
     def attribute_method_matchers=(value); end
     def attribute_method_matchers?; end
-    def attribute_type_decorations; end
-    def attribute_type_decorations=(value); end
-    def attribute_type_decorations?; end
     def attributes_to_define_after_schema_loads; end
     def attributes_to_define_after_schema_loads=(value); end
     def attributes_to_define_after_schema_loads?; end
@@ -1508,35 +1590,52 @@ class ActiveRecord::Base
     def collection_cache_versioning?; end
     def configurations; end
     def configurations=(config); end
+    def connected_to_stack; end
+    def connection_class; end
+    def connection_class=(b); end
+    def connection_class?; end
+    def connection_classes; end
     def connection_handler; end
     def connection_handler=(handler); end
     def connection_handlers; end
-    def connection_handlers=(val); end
-    def current_pool_key; end
-    def current_pool_key=(pool_key); end
+    def connection_handlers=(handlers); end
+    def current_preventing_writes; end
+    def current_role; end
+    def current_shard; end
     def default_connection_handler; end
     def default_connection_handler=(value); end
     def default_connection_handler?; end
-    def default_pool_key; end
-    def default_pool_key=(value); end
-    def default_pool_key?; end
+    def default_role; end
+    def default_role=(value); end
+    def default_role?; end
     def default_scope_override; end
     def default_scope_override=(value); end
     def default_scopes; end
     def default_scopes=(value); end
+    def default_shard; end
+    def default_shard=(value); end
+    def default_shard?; end
     def default_timezone; end
     def default_timezone=(val); end
     def defined_enums; end
     def defined_enums=(value); end
     def defined_enums?; end
+    def destroy_association_async_job; end
+    def destroy_association_async_job=(value); end
     def dump_schema_after_migration; end
     def dump_schema_after_migration=(val); end
     def dump_schemas; end
     def dump_schemas=(val); end
     def error_on_ignored_order; end
     def error_on_ignored_order=(val); end
+    def global_executor_concurrency; end
+    def global_executor_concurrency=(global_executor_concurrency); end
+    def global_thread_pool_async_query_executor; end
     def has_many_inversing; end
     def has_many_inversing=(val); end
+    def immutable_strings_by_default; end
+    def immutable_strings_by_default=(value); end
+    def immutable_strings_by_default?; end
     def implicit_order_column; end
     def implicit_order_column=(value); end
     def implicit_order_column?; end
@@ -1548,8 +1647,10 @@ class ActiveRecord::Base
     def internal_metadata_table_name; end
     def internal_metadata_table_name=(value); end
     def internal_metadata_table_name?; end
+    def legacy_connection_handling; end
+    def legacy_connection_handling=(val); end
     def local_stored_attributes; end
-    def local_stored_attributes=(_); end
+    def local_stored_attributes=(_arg0); end
     def lock_optimistically; end
     def lock_optimistically=(value); end
     def lock_optimistically?; end
@@ -1568,6 +1669,8 @@ class ActiveRecord::Base
     def pluralize_table_names?; end
     def primary_key_prefix_type; end
     def primary_key_prefix_type=(val); end
+    def queues; end
+    def queues=(val); end
     def reading_role; end
     def reading_role=(val); end
     def record_timestamps; end
@@ -1578,12 +1681,26 @@ class ActiveRecord::Base
     def schema_migrations_table_name; end
     def schema_migrations_table_name=(value); end
     def schema_migrations_table_name?; end
+    def signed_id_verifier_secret; end
+    def signed_id_verifier_secret=(val); end
     def skip_time_zone_conversion_for_attributes; end
     def skip_time_zone_conversion_for_attributes=(value); end
     def skip_time_zone_conversion_for_attributes?; end
+    def store_full_class_name; end
+    def store_full_class_name=(value); end
+    def store_full_class_name?; end
     def store_full_sti_class; end
     def store_full_sti_class=(value); end
     def store_full_sti_class?; end
+    def strict_loading_by_default; end
+    def strict_loading_by_default=(value); end
+    def strict_loading_by_default?; end
+    def strict_loading_mode; end
+    def strict_loading_mode=(value); end
+    def strict_loading_mode?; end
+    def strict_loading_violation!(owner:, reflection:); end
+    def suppress_multiple_database_warning; end
+    def suppress_multiple_database_warning=(val); end
     def table_name_prefix; end
     def table_name_prefix=(value); end
     def table_name_prefix?; end
@@ -1625,11 +1742,11 @@ class ActiveRecord::Batches::BatchEnumerator
 
   def initialize(relation:, of: T.unsafe(nil), start: T.unsafe(nil), finish: T.unsafe(nil)); end
 
-  def delete_all(*args, &block); end
-  def destroy_all(*args, &block); end
+  def delete_all; end
+  def destroy_all; end
   def each; end
   def each_record; end
-  def update_all(*args, &block); end
+  def update_all(updates); end
 end
 
 ActiveRecord::Batches::ORDER_IGNORE_MESSAGE = T.let(T.unsafe(nil), String)
@@ -1655,10 +1772,12 @@ module ActiveRecord::Calculations
   def execute_grouped_calculation(operation, column_name, distinct); end
   def execute_simple_calculation(operation, column_name, distinct); end
   def has_include?(column_name); end
-  def operation_over_aggregate_column(column_name, operation, distinct); end
+  def lookup_cast_type_from_join_dependencies(name, join_dependencies = T.unsafe(nil)); end
+  def operation_over_aggregate_column(column, operation, distinct); end
   def perform_calculation(operation, column_name); end
   def select_for_count; end
-  def type_cast_calculated_value(value, operation); end
+  def type_cast_calculated_value(value, operation, type); end
+  def type_cast_pluck_values(result, columns); end
   def type_for(field, &block); end
 end
 
@@ -1672,13 +1791,13 @@ module ActiveRecord::Callbacks
 
   def destroy; end
   def increment!(attribute, by = T.unsafe(nil), touch: T.unsafe(nil)); end
-  def touch(*_, **_); end
+  def touch(*_arg0, **_arg1); end
 
   private
 
   def _create_record; end
   def _update_record; end
-  def create_or_update(**_); end
+  def create_or_update(**_arg0); end
 end
 
 ActiveRecord::Callbacks::CALLBACKS = T.let(T.unsafe(nil), Array)
@@ -1704,7 +1823,7 @@ class ActiveRecord::Coders::YAMLColumn
   def dump(obj); end
   def load(yaml); end
   def object_class; end
-  def object_class=(_); end
+  def object_class=(_arg0); end
 
   private
 
@@ -1741,29 +1860,33 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
   def active?; end
   def adapter_name; end
   def advisory_locks_enabled?; end
+  def async_enabled?; end
   def build_insert_sql(insert); end
   def case_insensitive_comparison(attribute, value); end
   def case_sensitive_comparison(attribute, value); end
+  def check_if_write_query(sql); end
   def check_version; end
   def clear_cache!; end
   def close; end
+  def connection_klass; end
+  def create(*_arg0); end
   def database_version; end
   def default_index_type?(index); end
-  def default_uniqueness_comparison(attribute, value, klass); end
-  def delete(*_); end
+  def default_uniqueness_comparison(attribute, value); end
+  def delete(*_arg0); end
   def disable_extension(name); end
   def disable_referential_integrity; end
   def discard!; end
   def disconnect!; end
   def enable_extension(name); end
-  def exec_insert_all(*_); end
+  def exec_insert_all(*_arg0); end
   def expire; end
   def extensions; end
   def get_advisory_lock(lock_id); end
   def get_database_version; end
   def in_use?; end
   def index_algorithms; end
-  def insert(*_); end
+  def insert(*_arg0); end
   def lease; end
   def lock; end
   def logger; end
@@ -1771,9 +1894,10 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
   def migrations_paths; end
   def owner; end
   def pool; end
-  def pool=(_); end
+  def pool=(_arg0); end
   def prefetch_primary_key?(table_name = T.unsafe(nil)); end
   def prepared_statements; end
+  def prepared_statements?; end
   def prepared_statements_disabled_cache; end
   def preventing_writes?; end
   def raw_connection; end
@@ -1782,8 +1906,8 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
   def replica?; end
   def requires_reloading?; end
   def reset!; end
-  def rollback_db_transaction(*_); end
-  def rollback_to_savepoint(*_); end
+  def rollback_db_transaction(*_arg0); end
+  def rollback_to_savepoint(*_arg0); end
   def schema_cache; end
   def schema_cache=(cache); end
   def schema_migration; end
@@ -1791,16 +1915,17 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
   def steal!; end
   def supports_advisory_locks?; end
   def supports_bulk_alter?; end
+  def supports_check_constraints?; end
   def supports_comments?; end
   def supports_comments_in_create?; end
   def supports_common_table_expressions?; end
+  def supports_concurrent_connections?; end
   def supports_datetime_with_precision?; end
   def supports_ddl_transactions?; end
   def supports_explain?; end
   def supports_expression_index?; end
   def supports_extensions?; end
   def supports_foreign_keys?; end
-  def supports_foreign_keys_in_create?(*args, &block); end
   def supports_foreign_tables?; end
   def supports_index_sort_order?; end
   def supports_indexes_in_create?; end
@@ -1811,7 +1936,6 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
   def supports_json?; end
   def supports_lazy_transactions?; end
   def supports_materialized_views?; end
-  def supports_multi_insert?(*args, &block); end
   def supports_optimizer_hints?; end
   def supports_partial_index?; end
   def supports_partitioned_indexes?; end
@@ -1820,14 +1944,16 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
   def supports_validate_constraints?; end
   def supports_views?; end
   def supports_virtual_columns?; end
-  def truncate(*_); end
-  def truncate_tables(*_); end
+  def throw_away!; end
+  def truncate(*_arg0); end
+  def truncate_tables(*_arg0); end
   def unprepared_statement; end
-  def update(*_); end
+  def update(*_arg0); end
   def use_metadata_table?; end
   def valid_type?(type); end
   def verify!; end
   def visitor; end
+  def with_instrumenter(instrumenter, &block); end
 
   private
 
@@ -1842,7 +1968,7 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
   def extract_precision(sql_type); end
   def extract_scale(sql_type); end
   def initialize_type_map(m = T.unsafe(nil)); end
-  def log(sql, name = T.unsafe(nil), binds = T.unsafe(nil), type_casted_binds = T.unsafe(nil), statement_name = T.unsafe(nil)); end
+  def log(sql, name = T.unsafe(nil), binds = T.unsafe(nil), type_casted_binds = T.unsafe(nil), statement_name = T.unsafe(nil), async: T.unsafe(nil)); end
   def register_class_with_limit(mapping, key, klass); end
   def register_class_with_precision(mapping, key, klass); end
   def reload_type_map; end
@@ -1884,17 +2010,16 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter::Version
   def to_s; end
 end
 
-module ActiveRecord::ConnectionAdapters::AbstractPool
-  def get_schema_cache(connection); end
-  def set_schema_cache(cache); end
-end
-
 class ActiveRecord::ConnectionAdapters::AlterTable
   def initialize(td); end
 
+  def add_check_constraint(expression, options); end
   def add_column(name, type, **options); end
   def add_foreign_key(to_table, options); end
   def adds; end
+  def check_constraint_adds; end
+  def check_constraint_drops; end
+  def drop_check_constraint(constraint_name); end
   def drop_foreign_key(name); end
   def foreign_key_adds; end
   def foreign_key_drops; end
@@ -1908,10 +2033,30 @@ class ActiveRecord::ConnectionAdapters::ChangeColumnDefinition < ::Struct
   def name=(_); end
 
   class << self
-    def [](*_); end
+    def [](*_arg0); end
     def inspect; end
     def members; end
-    def new(*_); end
+    def new(*_arg0); end
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::CheckConstraintDefinition < ::Struct
+  def export_name_on_schema_dump?; end
+  def expression; end
+  def expression=(_); end
+  def name; end
+  def options; end
+  def options=(_); end
+  def table_name; end
+  def table_name=(_); end
+  def validate?; end
+  def validated?; end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
   end
 end
 
@@ -1919,7 +2064,7 @@ class ActiveRecord::ConnectionAdapters::Column
   include(::ActiveRecord::ConnectionAdapters::Deduplicable)
   extend(::ActiveRecord::ConnectionAdapters::Deduplicable::ClassMethods)
 
-  def initialize(name, default, sql_type_metadata = T.unsafe(nil), null = T.unsafe(nil), default_function = T.unsafe(nil), collation: T.unsafe(nil), comment: T.unsafe(nil), **_); end
+  def initialize(name, default, sql_type_metadata = T.unsafe(nil), null = T.unsafe(nil), default_function = T.unsafe(nil), collation: T.unsafe(nil), comment: T.unsafe(nil), **_arg7); end
 
   def ==(other); end
   def bigint?; end
@@ -1933,14 +2078,14 @@ class ActiveRecord::ConnectionAdapters::Column
   def hash; end
   def human_name; end
   def init_with(coder); end
-  def limit(*args, &block); end
+  def limit(*_arg0, &_arg1); end
   def name; end
   def null; end
-  def precision(*args, &block); end
-  def scale(*args, &block); end
-  def sql_type(*args, &block); end
+  def precision(*_arg0, &_arg1); end
+  def scale(*_arg0, &_arg1); end
+  def sql_type(*_arg0, &_arg1); end
   def sql_type_metadata; end
-  def type(*args, &block); end
+  def type(*_arg0, &_arg1); end
 
   private
 
@@ -1948,6 +2093,7 @@ class ActiveRecord::ConnectionAdapters::Column
 end
 
 class ActiveRecord::ConnectionAdapters::ColumnDefinition < ::Struct
+  def aliased_types(name, fallback); end
   def collation; end
   def collation=(value); end
   def comment; end
@@ -1973,32 +2119,33 @@ class ActiveRecord::ConnectionAdapters::ColumnDefinition < ::Struct
   def type=(_); end
 
   class << self
-    def [](*_); end
+    def [](*_arg0); end
     def inspect; end
     def members; end
-    def new(*_); end
+    def new(*_arg0); end
   end
 end
 
 class ActiveRecord::ConnectionAdapters::ConnectionHandler
   def initialize; end
 
-  def active_connections?; end
-  def clear_active_connections!; end
-  def clear_all_connections!; end
-  def clear_reloadable_connections!; end
-  def connected?(spec_name, pool_key = T.unsafe(nil)); end
-  def connection_pool_list; end
+  def active_connections?(role = T.unsafe(nil)); end
+  def all_connection_pools; end
+  def clear_active_connections!(role = T.unsafe(nil)); end
+  def clear_all_connections!(role = T.unsafe(nil)); end
+  def clear_reloadable_connections!(role = T.unsafe(nil)); end
+  def connected?(spec_name, role: T.unsafe(nil), shard: T.unsafe(nil)); end
+  def connection_pool_list(role = T.unsafe(nil)); end
   def connection_pool_names; end
-  def connection_pools; end
-  def establish_connection(config, pool_key = T.unsafe(nil), owner_name = T.unsafe(nil)); end
-  def flush_idle_connections!; end
+  def connection_pools(role = T.unsafe(nil)); end
+  def establish_connection(config, owner_name: T.unsafe(nil), role: T.unsafe(nil), shard: T.unsafe(nil)); end
+  def flush_idle_connections!(role = T.unsafe(nil)); end
   def prevent_writes; end
   def prevent_writes=(prevent_writes); end
   def remove_connection(*args, &block); end
-  def remove_connection_pool(owner, pool_key = T.unsafe(nil)); end
-  def retrieve_connection(spec_name, pool_key = T.unsafe(nil)); end
-  def retrieve_connection_pool(owner, pool_key = T.unsafe(nil)); end
+  def remove_connection_pool(owner, role: T.unsafe(nil), shard: T.unsafe(nil)); end
+  def retrieve_connection(spec_name, role: T.unsafe(nil), shard: T.unsafe(nil)); end
+  def retrieve_connection_pool(owner, role: T.unsafe(nil), shard: T.unsafe(nil)); end
   def while_preventing_writes(enabled = T.unsafe(nil)); end
 
   private
@@ -2016,16 +2163,18 @@ class ActiveRecord::ConnectionAdapters::ConnectionPool
   def initialize(pool_config); end
 
   def active_connection?; end
+  def async_executor; end
   def automatic_reconnect; end
-  def automatic_reconnect=(_); end
+  def automatic_reconnect=(_arg0); end
   def checkin(conn); end
   def checkout(checkout_timeout = T.unsafe(nil)); end
   def checkout_timeout; end
-  def checkout_timeout=(_); end
+  def checkout_timeout=(_arg0); end
   def clear_reloadable_connections(raise_on_acquisition_timeout = T.unsafe(nil)); end
   def clear_reloadable_connections!; end
   def connected?; end
   def connection; end
+  def connection_klass; end
   def connections; end
   def db_config; end
   def discard!; end
@@ -2041,7 +2190,8 @@ class ActiveRecord::ConnectionAdapters::ConnectionPool
   def reaper; end
   def release_connection(owner_thread = T.unsafe(nil)); end
   def remove(conn); end
-  def schema_cache(*args, &block); end
+  def schedule_query(future_result); end
+  def schema_cache(*_arg0, &_arg1); end
   def schema_cache=(arg); end
   def size; end
   def stat; end
@@ -2052,6 +2202,7 @@ class ActiveRecord::ConnectionAdapters::ConnectionPool
   def acquire_connection(checkout_timeout); end
   def adopt_connection(conn); end
   def attempt_to_checkout_all_existing_connections(raise_on_acquisition_timeout = T.unsafe(nil)); end
+  def build_async_executor; end
   def bulk_make_new_connections(num_new_conns_needed); end
   def checkout_and_verify(c); end
   def checkout_for_exclusive_access(checkout_timeout); end
@@ -2127,17 +2278,10 @@ end
 
 module ActiveRecord::ConnectionAdapters::DatabaseLimits
   def allowed_index_name_length(*args, &block); end
-  def column_name_length(*args, &block); end
-  def columns_per_multicolumn_index(*args, &block); end
-  def columns_per_table(*args, &block); end
   def in_clause_length(*args, &block); end
   def index_name_length; end
-  def indexes_per_table(*args, &block); end
-  def joins_per_query(*args, &block); end
   def max_identifier_length; end
-  def sql_query_length(*args, &block); end
   def table_alias_length; end
-  def table_name_length(*args, &block); end
 
   private
 
@@ -2147,20 +2291,20 @@ end
 module ActiveRecord::ConnectionAdapters::DatabaseStatements
   def initialize; end
 
-  def add_transaction_record(record); end
+  def add_transaction_record(record, ensure_finalize = T.unsafe(nil)); end
   def begin_db_transaction; end
   def begin_isolated_db_transaction(isolation); end
-  def begin_transaction(*args, &block); end
+  def begin_transaction(*_arg0, &_arg1); end
   def cacheable_query(klass, arel); end
   def commit_db_transaction; end
-  def commit_transaction(*args, &block); end
+  def commit_transaction(*_arg0, &_arg1); end
   def create(arel, name = T.unsafe(nil), pk = T.unsafe(nil), id_value = T.unsafe(nil), sequence_name = T.unsafe(nil), binds = T.unsafe(nil)); end
-  def current_transaction(*args, &block); end
+  def current_transaction(*_arg0, &_arg1); end
   def default_sequence_name(table, column); end
   def delete(arel, name = T.unsafe(nil), binds = T.unsafe(nil)); end
-  def disable_lazy_transactions!(*args, &block); end
+  def disable_lazy_transactions!(*_arg0, &_arg1); end
   def empty_insert_statement_value(primary_key = T.unsafe(nil)); end
-  def enable_lazy_transactions!(*args, &block); end
+  def enable_lazy_transactions!(*_arg0, &_arg1); end
   def exec_delete(sql, name = T.unsafe(nil), binds = T.unsafe(nil)); end
   def exec_insert(sql, name = T.unsafe(nil), binds = T.unsafe(nil), pk = T.unsafe(nil), sequence_name = T.unsafe(nil)); end
   def exec_insert_all(sql, name); end
@@ -2168,11 +2312,13 @@ module ActiveRecord::ConnectionAdapters::DatabaseStatements
   def exec_rollback_db_transaction; end
   def exec_update(sql, name = T.unsafe(nil), binds = T.unsafe(nil)); end
   def execute(sql, name = T.unsafe(nil)); end
+  def explain(arel, binds = T.unsafe(nil)); end
   def insert(arel, name = T.unsafe(nil), pk = T.unsafe(nil), id_value = T.unsafe(nil), sequence_name = T.unsafe(nil), binds = T.unsafe(nil)); end
   def insert_fixture(fixture, table_name); end
   def insert_fixtures_set(fixture_set, tables_to_delete = T.unsafe(nil)); end
-  def materialize_transactions(*args, &block); end
-  def open_transactions(*args, &block); end
+  def mark_transaction_written_if_write(sql); end
+  def materialize_transactions(*_arg0, &_arg1); end
+  def open_transactions(*_arg0, &_arg1); end
   def query(sql, name = T.unsafe(nil)); end
   def query_value(sql, name = T.unsafe(nil)); end
   def query_values(sql, name = T.unsafe(nil)); end
@@ -2180,9 +2326,9 @@ module ActiveRecord::ConnectionAdapters::DatabaseStatements
   def reset_transaction; end
   def rollback_db_transaction; end
   def rollback_to_savepoint(name = T.unsafe(nil)); end
-  def rollback_transaction(*args, &block); end
+  def rollback_transaction(*_arg0, &_arg1); end
   def sanitize_limit(limit); end
-  def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil)); end
+  def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil), async: T.unsafe(nil)); end
   def select_one(arel, name = T.unsafe(nil), binds = T.unsafe(nil)); end
   def select_rows(arel, name = T.unsafe(nil), binds = T.unsafe(nil)); end
   def select_value(arel, name = T.unsafe(nil), binds = T.unsafe(nil)); end
@@ -2192,12 +2338,11 @@ module ActiveRecord::ConnectionAdapters::DatabaseStatements
   def transaction_isolation_levels; end
   def transaction_manager; end
   def transaction_open?; end
-  def transaction_state; end
   def truncate(table_name, name = T.unsafe(nil)); end
   def truncate_tables(*table_names); end
   def update(arel, name = T.unsafe(nil), binds = T.unsafe(nil)); end
   def with_yaml_fallback(value); end
-  def within_new_transaction(*args, &block); end
+  def within_new_transaction(*_arg0, &_arg1); end
   def write_query?(sql); end
 
   private
@@ -2211,8 +2356,7 @@ module ActiveRecord::ConnectionAdapters::DatabaseStatements
   def default_insert_value(column); end
   def execute_batch(statements, name = T.unsafe(nil)); end
   def last_inserted_id(result); end
-  def select(sql, name = T.unsafe(nil), binds = T.unsafe(nil)); end
-  def select_prepared(sql, name = T.unsafe(nil), binds = T.unsafe(nil)); end
+  def select(sql, name = T.unsafe(nil), binds = T.unsafe(nil), prepare: T.unsafe(nil), async: T.unsafe(nil)); end
   def single_value_from_rows(rows); end
   def sql_for_insert(sql, pk, binds); end
   def to_sql_and_binds(arel_or_sql_string, binds = T.unsafe(nil), preparable = T.unsafe(nil)); end
@@ -2242,16 +2386,17 @@ class ActiveRecord::ConnectionAdapters::ForeignKeyDefinition < ::Struct
   def default_primary_key; end
 
   class << self
-    def [](*_); end
+    def [](*_arg0); end
     def inspect; end
     def members; end
-    def new(*_); end
+    def new(*_arg0); end
   end
 end
 
 class ActiveRecord::ConnectionAdapters::IndexDefinition
   def initialize(table, name, unique = T.unsafe(nil), columns = T.unsafe(nil), lengths: T.unsafe(nil), orders: T.unsafe(nil), opclasses: T.unsafe(nil), where: T.unsafe(nil), type: T.unsafe(nil), using: T.unsafe(nil), comment: T.unsafe(nil)); end
 
+  def column_options; end
   def columns; end
   def comment; end
   def lengths; end
@@ -2269,17 +2414,28 @@ class ActiveRecord::ConnectionAdapters::IndexDefinition
   def concise_options(options); end
 end
 
+class ActiveRecord::ConnectionAdapters::LegacyPoolManager
+  def initialize; end
+
+  def get_pool_config(_, shard); end
+  def pool_configs(_ = T.unsafe(nil)); end
+  def remove_pool_config(_, shard); end
+  def set_pool_config(_, shard, pool_config); end
+  def shard_names; end
+end
+
 class ActiveRecord::ConnectionAdapters::NullPool
   include(::ActiveRecord::ConnectionAdapters::AbstractPool)
 
+  def connection_klass; end
   def schema_cache; end
-  def schema_cache=(_); end
+  def schema_cache=(_arg0); end
 end
 
 class ActiveRecord::ConnectionAdapters::NullTransaction
   def initialize; end
 
-  def add_record(record); end
+  def add_record(record, _ = T.unsafe(nil)); end
   def closed?; end
   def joinable?; end
   def open?; end
@@ -2289,8 +2445,9 @@ end
 class ActiveRecord::ConnectionAdapters::PoolConfig
   include(::Mutex_m)
 
-  def initialize(connection_specification_name, db_config); end
+  def initialize(connection_klass, db_config); end
 
+  def connection_klass; end
   def connection_specification_name; end
   def db_config; end
   def discard_pool!; end
@@ -2299,7 +2456,7 @@ class ActiveRecord::ConnectionAdapters::PoolConfig
   def locked?; end
   def pool; end
   def schema_cache; end
-  def schema_cache=(_); end
+  def schema_cache=(_arg0); end
   def synchronize(&block); end
   def try_lock; end
   def unlock; end
@@ -2312,14 +2469,17 @@ end
 class ActiveRecord::ConnectionAdapters::PoolManager
   def initialize; end
 
-  def get_pool_config(key); end
-  def pool_configs; end
-  def remove_pool_config(key); end
-  def set_pool_config(key, pool_config); end
+  def get_pool_config(role, shard); end
+  def pool_configs(role = T.unsafe(nil)); end
+  def remove_pool_config(role, shard); end
+  def remove_role(role); end
+  def role_names; end
+  def set_pool_config(role, shard, pool_config); end
+  def shard_names; end
 end
 
 module ActiveRecord::ConnectionAdapters::QueryCache
-  def initialize(*_); end
+  def initialize(*_arg0); end
 
   def cache; end
   def clear_query_cache; end
@@ -2327,7 +2487,7 @@ module ActiveRecord::ConnectionAdapters::QueryCache
   def enable_query_cache!; end
   def query_cache; end
   def query_cache_enabled; end
-  def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil)); end
+  def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil), async: T.unsafe(nil)); end
   def uncached; end
 
   private
@@ -2335,7 +2495,7 @@ module ActiveRecord::ConnectionAdapters::QueryCache
   def cache_notification_info(sql, name, binds); end
   def cache_sql(sql, name, binds); end
   def configure_query_cache!; end
-  def locked?(arel); end
+  def lookup_sql_cache(sql, name, binds); end
 
   class << self
     def dirties_query_cache(base, *method_names); end
@@ -2344,7 +2504,7 @@ module ActiveRecord::ConnectionAdapters::QueryCache
 end
 
 module ActiveRecord::ConnectionAdapters::QueryCache::ConnectionPoolConfiguration
-  def initialize(*_); end
+  def initialize(*_arg0); end
 
   def disable_query_cache!; end
   def enable_query_cache!; end
@@ -2375,7 +2535,6 @@ module ActiveRecord::ConnectionAdapters::Quoting
 
   def _quote(value); end
   def _type_cast(value); end
-  def id_value_for_database(value); end
   def lookup_cast_type(sql_type); end
   def type_casted_binds(binds); end
 end
@@ -2401,10 +2560,11 @@ class ActiveRecord::ConnectionAdapters::ReferenceDefinition
   def foreign_key_options; end
   def foreign_table_name; end
   def index; end
-  def index_options; end
+  def index_options(table_name); end
   def name; end
   def options; end
   def polymorphic; end
+  def polymorphic_index_name(table_name); end
   def polymorphic_options; end
   def type; end
 end
@@ -2429,19 +2589,23 @@ module ActiveRecord::ConnectionAdapters::SchemaStatements
   include(::ActiveRecord::Migration::JoinTable)
 
   def add_belongs_to(table_name, ref_name, **options); end
+  def add_check_constraint(table_name, expression, **options); end
   def add_column(table_name, column_name, type, **options); end
+  def add_columns(table_name, *column_names, type:, **options); end
   def add_foreign_key(from_table, to_table, **options); end
-  def add_index(table_name, column_name, options = T.unsafe(nil)); end
-  def add_index_options(table_name, column_name, comment: T.unsafe(nil), **options); end
+  def add_index(table_name, column_name, **options); end
+  def add_index_options(table_name, column_name, name: T.unsafe(nil), if_not_exists: T.unsafe(nil), internal: T.unsafe(nil), **options); end
   def add_reference(table_name, ref_name, **options); end
   def add_timestamps(table_name, **options); end
-  def assume_migrated_upto_version(version, migrations_paths = T.unsafe(nil)); end
-  def change_column(table_name, column_name, type, options = T.unsafe(nil)); end
+  def assume_migrated_upto_version(version); end
+  def change_column(table_name, column_name, type, **options); end
   def change_column_comment(table_name, column_name, comment_or_changes); end
   def change_column_default(table_name, column_name, default_or_changes); end
   def change_column_null(table_name, column_name, null, default = T.unsafe(nil)); end
   def change_table(table_name, **options); end
   def change_table_comment(table_name, comment_or_changes); end
+  def check_constraint_options(table_name, expression, options); end
+  def check_constraints(table_name); end
   def column_exists?(table_name, column_name, type = T.unsafe(nil), **options); end
   def columns(table_name); end
   def columns_for_distinct(columns, orders); end
@@ -2450,6 +2614,7 @@ module ActiveRecord::ConnectionAdapters::SchemaStatements
   def create_table(table_name, id: T.unsafe(nil), primary_key: T.unsafe(nil), force: T.unsafe(nil), **options); end
   def data_source_exists?(name); end
   def data_sources; end
+  def distinct_relation_for_primary_key(relation); end
   def drop_join_table(table_1, table_2, **options); end
   def drop_table(table_name, **options); end
   def dump_schema_information; end
@@ -2457,7 +2622,8 @@ module ActiveRecord::ConnectionAdapters::SchemaStatements
   def foreign_key_exists?(from_table, to_table = T.unsafe(nil), **options); end
   def foreign_key_options(from_table, to_table, options); end
   def foreign_keys(table_name); end
-  def index_exists?(table_name, column_name, options = T.unsafe(nil)); end
+  def index_algorithm(algorithm); end
+  def index_exists?(table_name, column_name, **options); end
   def index_name(table_name, options); end
   def index_name_exists?(table_name, index_name); end
   def indexes(table_name); end
@@ -2465,11 +2631,13 @@ module ActiveRecord::ConnectionAdapters::SchemaStatements
   def native_database_types; end
   def options_include_default?(options); end
   def primary_key(table_name); end
+  def quoted_columns_for_index(column_names, options); end
   def remove_belongs_to(table_name, ref_name, foreign_key: T.unsafe(nil), polymorphic: T.unsafe(nil), **options); end
+  def remove_check_constraint(table_name, expression = T.unsafe(nil), **options); end
   def remove_column(table_name, column_name, type = T.unsafe(nil), **options); end
-  def remove_columns(table_name, *column_names, **options); end
+  def remove_columns(table_name, *column_names, type: T.unsafe(nil), **options); end
   def remove_foreign_key(from_table, to_table = T.unsafe(nil), **options); end
-  def remove_index(table_name, column_name = T.unsafe(nil), options = T.unsafe(nil)); end
+  def remove_index(table_name, column_name = T.unsafe(nil), **options); end
   def remove_reference(table_name, ref_name, foreign_key: T.unsafe(nil), polymorphic: T.unsafe(nil), **options); end
   def remove_timestamps(table_name, **options); end
   def rename_column(table_name, column_name, new_column_name); end
@@ -2480,7 +2648,7 @@ module ActiveRecord::ConnectionAdapters::SchemaStatements
   def table_exists?(table_name); end
   def table_options(table_name); end
   def tables; end
-  def type_to_sql(type, limit: T.unsafe(nil), precision: T.unsafe(nil), scale: T.unsafe(nil), **_); end
+  def type_to_sql(type, limit: T.unsafe(nil), precision: T.unsafe(nil), scale: T.unsafe(nil), **_arg4); end
   def update_table_definition(table_name, base); end
   def view_exists?(view_name); end
   def views; end
@@ -2493,13 +2661,17 @@ module ActiveRecord::ConnectionAdapters::SchemaStatements
   def add_timestamps_for_alter(table_name, **options); end
   def bulk_change_table(table_name, operations); end
   def can_remove_index_by_name?(column_name, options); end
+  def check_constraint_for(table_name, **options); end
+  def check_constraint_for!(table_name, expression: T.unsafe(nil), **options); end
+  def check_constraint_name(table_name, **options); end
   def column_options_keys; end
   def create_alter_table(name); end
-  def create_table_definition(*args, **options); end
+  def create_table_definition(name, **options); end
   def data_source_sql(name = T.unsafe(nil), type: T.unsafe(nil)); end
   def extract_foreign_key_action(specifier); end
   def extract_new_comment_value(default_or_changes); end
   def extract_new_default_value(default_or_changes); end
+  def extract_table_options!(options); end
   def fetch_type_metadata(sql_type); end
   def foreign_key_for(from_table, **options); end
   def foreign_key_for!(from_table, to_table: T.unsafe(nil), **options); end
@@ -2509,12 +2681,12 @@ module ActiveRecord::ConnectionAdapters::SchemaStatements
   def index_name_options(column_names); end
   def insert_versions_sql(versions); end
   def options_for_index_columns(options); end
-  def quoted_columns_for_index(column_names, **options); end
   def quoted_scope(name = T.unsafe(nil), type: T.unsafe(nil)); end
   def remove_column_for_alter(table_name, column_name, type = T.unsafe(nil), **options); end
   def remove_columns_for_alter(table_name, *column_names, **options); end
   def remove_timestamps_for_alter(table_name, **options); end
   def rename_column_indexes(table_name, column_name, new_column_name); end
+  def rename_column_sql(table_name, column_name, new_column_name); end
   def rename_table_indexes(table_name, new_name); end
   def schema_creation; end
   def strip_table_name_prefix_and_suffix(table_name); end
@@ -2530,11 +2702,13 @@ class ActiveRecord::ConnectionAdapters::Table
   def belongs_to(*args, **options); end
   def bigint(*names, **options); end
   def binary(*names, **options); end
+  def blob(*names, **options); end
   def boolean(*names, **options); end
-  def change(column_name, type, options = T.unsafe(nil)); end
+  def change(column_name, type, **options); end
   def change_default(column_name, default_or_changes); end
   def change_null(column_name, null, default = T.unsafe(nil)); end
-  def column(column_name, type, **options); end
+  def check_constraint(*args); end
+  def column(column_name, type, index: T.unsafe(nil), **options); end
   def column_exists?(column_name, type = T.unsafe(nil), **options); end
   def date(*names, **options); end
   def datetime(*names, **options); end
@@ -2542,7 +2716,7 @@ class ActiveRecord::ConnectionAdapters::Table
   def float(*names, **options); end
   def foreign_key(*args, **options); end
   def foreign_key_exists?(*args, **options); end
-  def index(column_name, options = T.unsafe(nil)); end
+  def index(column_name, **options); end
   def index_exists?(column_name, options = T.unsafe(nil)); end
   def integer(*names, **options); end
   def json(*names, **options); end
@@ -2551,8 +2725,9 @@ class ActiveRecord::ConnectionAdapters::Table
   def references(*args, **options); end
   def remove(*column_names, **options); end
   def remove_belongs_to(*args, **options); end
+  def remove_check_constraint(*args); end
   def remove_foreign_key(*args, **options); end
-  def remove_index(column_name = T.unsafe(nil), options = T.unsafe(nil)); end
+  def remove_index(column_name = T.unsafe(nil), **options); end
   def remove_references(*args, **options); end
   def remove_timestamps(**options); end
   def rename(column_name, new_column_name); end
@@ -2569,15 +2744,18 @@ class ActiveRecord::ConnectionAdapters::TableDefinition
   include(::ActiveRecord::ConnectionAdapters::ColumnMethods)
   extend(::ActiveRecord::ConnectionAdapters::ColumnMethods::ClassMethods)
 
-  def initialize(conn, name, temporary: T.unsafe(nil), if_not_exists: T.unsafe(nil), options: T.unsafe(nil), as: T.unsafe(nil), comment: T.unsafe(nil)); end
+  def initialize(conn, name, temporary: T.unsafe(nil), if_not_exists: T.unsafe(nil), options: T.unsafe(nil), as: T.unsafe(nil), comment: T.unsafe(nil), **_arg7); end
 
   def [](name); end
   def as; end
   def belongs_to(*args, **options); end
   def bigint(*names, **options); end
   def binary(*names, **options); end
+  def blob(*names, **options); end
   def boolean(*names, **options); end
-  def column(name, type, **options); end
+  def check_constraint(expression, **options); end
+  def check_constraints; end
+  def column(name, type, index: T.unsafe(nil), **options); end
   def columns; end
   def comment; end
   def date(*names, **options); end
@@ -2587,7 +2765,7 @@ class ActiveRecord::ConnectionAdapters::TableDefinition
   def foreign_key(table_name, **options); end
   def foreign_keys; end
   def if_not_exists; end
-  def index(column_name, options = T.unsafe(nil)); end
+  def index(column_name, **options); end
   def indexes; end
   def integer(*names, **options); end
   def json(*names, **options); end
@@ -2654,36 +2832,38 @@ class ActiveRecord::ConnectionAdapters::TransactionState
 end
 
 module ActiveRecord::ConnectionHandling
-  def clear_active_connections!(*args, &block); end
-  def clear_all_connections!(*args, &block); end
+  def clear_active_connections!(*_arg0, &_arg1); end
+  def clear_all_connections!(*_arg0, &_arg1); end
   def clear_cache!; end
   def clear_query_caches_for_current_thread; end
-  def clear_reloadable_connections!(*args, &block); end
+  def clear_reloadable_connections!(*_arg0, &_arg1); end
   def connected?; end
-  def connected_to(database: T.unsafe(nil), role: T.unsafe(nil), shard: T.unsafe(nil), prevent_writes: T.unsafe(nil), &blk); end
+  def connected_to(role: T.unsafe(nil), shard: T.unsafe(nil), prevent_writes: T.unsafe(nil), &blk); end
   def connected_to?(role:, shard: T.unsafe(nil)); end
+  def connected_to_many(*classes, role:, shard: T.unsafe(nil), prevent_writes: T.unsafe(nil)); end
+  def connecting_to(role: T.unsafe(nil), shard: T.unsafe(nil), prevent_writes: T.unsafe(nil)); end
   def connection; end
   def connection_config(*args, &block); end
   def connection_db_config; end
   def connection_pool; end
   def connection_specification_name; end
-  def connection_specification_name=(_); end
+  def connection_specification_name=(_arg0); end
   def connects_to(database: T.unsafe(nil), shards: T.unsafe(nil)); end
-  def current_role; end
   def establish_connection(config_or_env = T.unsafe(nil)); end
-  def flush_idle_connections!(*args, &block); end
+  def flush_idle_connections!(*_arg0, &_arg1); end
   def lookup_connection_handler(handler_key); end
   def primary_class?; end
   def remove_connection(name = T.unsafe(nil)); end
   def retrieve_connection; end
+  def while_preventing_writes(enabled = T.unsafe(nil), &block); end
 
   private
 
+  def clear_on_handler(handler); end
   def resolve_config_for_connection(config_or_env); end
   def swap_connection_handler(handler, &blk); end
   def with_handler(handler_key, &blk); end
-  def with_role(role, prevent_writes, &blk); end
-  def with_shard(pool_key, role, prevent_writes); end
+  def with_role_and_shard(role, shard, prevent_writes); end
 end
 
 ActiveRecord::ConnectionHandling::DEFAULT_ENV = T.let(T.unsafe(nil), Proc)
@@ -2720,8 +2900,10 @@ module ActiveRecord::Core
   def readonly!; end
   def readonly?; end
   def slice(*methods); end
-  def strict_loading!; end
+  def strict_loading!(value = T.unsafe(nil), mode: T.unsafe(nil)); end
   def strict_loading?; end
+  def strict_loading_n_plus_one_only?; end
+  def values_at(*methods); end
 
   private
 
@@ -2735,11 +2917,11 @@ end
 
 module ActiveRecord::Core::ClassMethods
   def ===(object); end
-  def _internal?; end
-  def arel_attribute(name, table = T.unsafe(nil)); end
+  def arel_attribute(*args, &block); end
   def arel_table; end
+  def cached_find_by_statement(key, &block); end
   def filter_attributes; end
-  def filter_attributes=(_); end
+  def filter_attributes=(filter_attributes); end
   def find(*ids); end
   def find_by(*args); end
   def find_by!(*args); end
@@ -2748,12 +2930,12 @@ module ActiveRecord::Core::ClassMethods
   def initialize_find_by_cache; end
   def initialize_generated_modules; end
   def inspect; end
+  def inspection_filter; end
   def predicate_builder; end
   def type_caster; end
 
   private
 
-  def cached_find_by_statement(key, &block); end
   def relation; end
   def table_metadata; end
 end
@@ -2788,15 +2970,14 @@ class ActiveRecord::DatabaseConfigurations
   def initialize(configurations = T.unsafe(nil)); end
 
   def [](*args, &block); end
-  def any?(*args, &block); end
+  def any?(*_arg0, &_arg1); end
   def blank?; end
   def configs_for(env_name: T.unsafe(nil), spec_name: T.unsafe(nil), name: T.unsafe(nil), include_replicas: T.unsafe(nil)); end
   def configurations; end
   def default_hash(*args, &block); end
-  def each; end
   def empty?; end
   def find_db_config(env); end
-  def first; end
+  def primary?(name); end
   def resolve(config); end
   def to_h(*args, &block); end
 
@@ -2812,10 +2993,7 @@ class ActiveRecord::DatabaseConfigurations
   def environment_url_config(env, name, config); end
   def environment_value_for(name); end
   def merge_db_environment_variables(current_env, configs); end
-  def method_missing(method, *args, &blk); end
   def resolve_symbol_connection(name); end
-  def throw_getter_deprecation(method); end
-  def throw_setter_deprecation(method); end
   def walk_configs(env_name, config); end
 end
 
@@ -2846,10 +3024,13 @@ class ActiveRecord::DatabaseConfigurations::DatabaseConfig
   def for_current_env?; end
   def host; end
   def idle_timeout; end
+  def max_queue; end
+  def max_threads; end
   def migrations_paths; end
+  def min_threads; end
   def name; end
   def owner_name; end
-  def owner_name=(_); end
+  def owner_name=(_arg0); end
   def pool; end
   def reaping_frequency; end
   def replica?; end
@@ -2868,7 +3049,10 @@ class ActiveRecord::DatabaseConfigurations::HashConfig < ::ActiveRecord::Databas
   def database; end
   def host; end
   def idle_timeout; end
+  def max_queue; end
+  def max_threads; end
   def migrations_paths; end
+  def min_threads; end
   def pool; end
   def reaping_frequency; end
   def replica?; end
@@ -2891,37 +3075,45 @@ end
 class ActiveRecord::Deadlocked < ::ActiveRecord::TransactionRollbackError
 end
 
+module ActiveRecord::DelegatedType
+  def delegated_type(role, types:, **options); end
+
+  private
+
+  def define_delegated_type_methods(role, types:, options:); end
+end
+
 module ActiveRecord::Delegation
   extend(::ActiveSupport::Concern)
 
   mixes_in_class_methods(::ActiveRecord::Delegation::ClassMethods)
 
-  def &(*args, &block); end
-  def +(*args, &block); end
-  def -(*args, &block); end
-  def [](*args, &block); end
-  def as_json(*args, &block); end
-  def compact(*args, &block); end
-  def connection(*args, &block); end
-  def each(*args, &block); end
-  def encode_with(*args, &block); end
-  def in_groups(*args, &block); end
-  def in_groups_of(*args, &block); end
-  def index(*args, &block); end
-  def join(*args, &block); end
-  def length(*args, &block); end
-  def primary_key(*args, &block); end
-  def reverse(*args, &block); end
-  def rindex(*args, &block); end
-  def rotate(*args, &block); end
-  def sample(*args, &block); end
-  def shuffle(*args, &block); end
-  def slice(*args, &block); end
-  def split(*args, &block); end
-  def to_formatted_s(*args, &block); end
-  def to_sentence(*args, &block); end
-  def to_xml(*args, &block); end
-  def |(*args, &block); end
+  def &(*_arg0, &_arg1); end
+  def +(*_arg0, &_arg1); end
+  def -(*_arg0, &_arg1); end
+  def [](*_arg0, &_arg1); end
+  def as_json(*_arg0, &_arg1); end
+  def compact(*_arg0, &_arg1); end
+  def connection(*_arg0, &_arg1); end
+  def each(*_arg0, &_arg1); end
+  def encode_with(*_arg0, &_arg1); end
+  def in_groups(*_arg0, &_arg1); end
+  def in_groups_of(*_arg0, &_arg1); end
+  def index(*_arg0, &_arg1); end
+  def join(*_arg0, &_arg1); end
+  def length(*_arg0, &_arg1); end
+  def primary_key(*_arg0, &_arg1); end
+  def reverse(*_arg0, &_arg1); end
+  def rindex(*_arg0, &_arg1); end
+  def rotate(*_arg0, &_arg1); end
+  def sample(*_arg0, &_arg1); end
+  def shuffle(*_arg0, &_arg1); end
+  def slice(*_arg0, &_arg1); end
+  def split(*_arg0, &_arg1); end
+  def to_formatted_s(*_arg0, &_arg1); end
+  def to_sentence(*_arg0, &_arg1); end
+  def to_xml(*_arg0, &_arg1); end
+  def |(*_arg0, &_arg1); end
 
   private
 
@@ -2970,6 +3162,19 @@ class ActiveRecord::DeleteRestrictionError < ::ActiveRecord::ActiveRecordError
   def initialize(name = T.unsafe(nil)); end
 end
 
+class ActiveRecord::DestroyAssociationAsyncJob < ::ActiveJob::Base
+  def perform(owner_model_name: T.unsafe(nil), owner_id: T.unsafe(nil), association_class: T.unsafe(nil), association_ids: T.unsafe(nil), association_primary_key_column: T.unsafe(nil), ensuring_owner_was_method: T.unsafe(nil)); end
+
+  private
+
+  def owner_destroyed?(owner, ensuring_owner_was_method); end
+
+  class << self
+    def queue_name; end
+    def rescue_handlers; end
+  end
+end
+
 module ActiveRecord::DynamicMatchers
 
   private
@@ -3025,15 +3230,16 @@ class ActiveRecord::EagerLoadPolymorphicError < ::ActiveRecord::ActiveRecordErro
 end
 
 module ActiveRecord::Enum
-  def enum(definitions); end
+  def enum(name = T.unsafe(nil), values = T.unsafe(nil), **options); end
   def inherited(base); end
 
   private
 
+  def _enum(name, values, prefix: T.unsafe(nil), suffix: T.unsafe(nil), scopes: T.unsafe(nil), **options); end
   def _enum_methods_module; end
   def assert_valid_enum_definition_values(values); end
   def detect_enum_conflict!(enum_name, method_name, klass_method = T.unsafe(nil)); end
-  def detect_negative_condition!(method_name); end
+  def detect_negative_enum_conditions!(method_names); end
   def raise_conflict_error(enum_name, method_name, type: T.unsafe(nil), source: T.unsafe(nil)); end
 
   class << self
@@ -3047,16 +3253,15 @@ class ActiveRecord::Enum::EnumType < ::ActiveModel::Type::Value
   def assert_valid_value(value); end
   def cast(value); end
   def deserialize(value); end
-  def serializable?(value); end
+  def serializable?(value, &block); end
   def serialize(value); end
-  def type(*args, &block); end
-  def unchecked_serialize(value); end
+  def subtype; end
+  def type(*_arg0, &_arg1); end
 
   private
 
   def mapping; end
   def name; end
-  def subtype; end
 end
 
 class ActiveRecord::ExclusiveConnectionTimeoutError < ::ActiveRecord::ConnectionTimeoutError
@@ -3077,10 +3282,10 @@ class ActiveRecord::ExplainRegistry
   def initialize; end
 
   def collect; end
-  def collect=(_); end
+  def collect=(_arg0); end
   def collect?; end
   def queries; end
-  def queries=(_); end
+  def queries=(_arg0); end
   def reset; end
 end
 
@@ -3101,19 +3306,23 @@ module ActiveRecord::FinderMethods
   def find(*args); end
   def find_by(arg, *args); end
   def find_by!(arg, *args); end
+  def find_sole_by(arg, *args); end
   def first(limit = T.unsafe(nil)); end
   def first!; end
   def forty_two; end
   def forty_two!; end
   def fourth; end
   def fourth!; end
+  def include?(record); end
   def last(limit = T.unsafe(nil)); end
   def last!; end
+  def member?(record); end
   def raise_record_not_found_exception!(ids = T.unsafe(nil), result_size = T.unsafe(nil), expected_size = T.unsafe(nil), key = T.unsafe(nil), not_found_ids = T.unsafe(nil)); end
   def second; end
   def second!; end
   def second_to_last; end
   def second_to_last!; end
+  def sole; end
   def take(limit = T.unsafe(nil)); end
   def take!; end
   def third; end
@@ -3124,6 +3333,7 @@ module ActiveRecord::FinderMethods
   private
 
   def apply_join_dependency(eager_loading: T.unsafe(nil)); end
+  def check_reorder_deprecation; end
   def construct_relation_for_exists(conditions); end
   def find_last(limit); end
   def find_nth(index); end
@@ -3135,16 +3345,55 @@ module ActiveRecord::FinderMethods
   def find_take; end
   def find_take_with_limit(limit); end
   def find_with_ids(*ids); end
-  def limited_ids_for(relation); end
-  def offset_index; end
   def ordered_relation; end
   def using_limitable_reflections?(reflections); end
 end
 
 ActiveRecord::FinderMethods::ONE_AS_ONE = T.let(T.unsafe(nil), String)
 
+class ActiveRecord::FutureResult
+  def initialize(pool, *args, **kwargs); end
+
+  def cancel; end
+  def empty?(*_arg0, &_arg1); end
+  def execute!(connection); end
+  def execute_or_skip; end
+  def pending?; end
+  def result; end
+  def schedule!(session); end
+  def to_a(*_arg0, &_arg1); end
+
+  private
+
+  def canceled?; end
+  def exec_query(connection, *args, **kwargs); end
+  def execute_or_wait; end
+  def execute_query(connection, async: T.unsafe(nil)); end
+end
+
+class ActiveRecord::FutureResult::Canceled < ::ActiveRecord::ActiveRecordError
+end
+
+class ActiveRecord::FutureResult::SelectAll < ::ActiveRecord::FutureResult
+
+  private
+
+  def exec_query(*_arg0, **_arg1); end
+end
+
 class ActiveRecord::HasManyThroughAssociationNotFoundError < ::ActiveRecord::ActiveRecordError
-  def initialize(owner_class_name = T.unsafe(nil), reflection = T.unsafe(nil)); end
+  include(::DidYouMean::Correctable)
+
+  def initialize(owner_class = T.unsafe(nil), reflection = T.unsafe(nil)); end
+
+  def owner_class; end
+  def reflection; end
+end
+
+class ActiveRecord::HasManyThroughAssociationNotFoundError::Correction
+  def initialize(error); end
+
+  def corrections; end
 end
 
 class ActiveRecord::HasManyThroughAssociationPointlessSourceTypeError < ::ActiveRecord::ActiveRecordError
@@ -3205,7 +3454,7 @@ end
 
 module ActiveRecord::Inheritance::ClassMethods
   def abstract_class; end
-  def abstract_class=(_); end
+  def abstract_class=(_arg0); end
   def abstract_class?; end
   def base_class; end
   def base_class?; end
@@ -3215,6 +3464,7 @@ module ActiveRecord::Inheritance::ClassMethods
   def new(attributes = T.unsafe(nil), &block); end
   def polymorphic_class_for(name); end
   def polymorphic_name; end
+  def primary_abstract_class; end
   def sti_class_for(type_name); end
   def sti_name; end
 
@@ -3265,13 +3515,13 @@ class ActiveRecord::InsertAll::Builder
 
   def conflict_target; end
   def into; end
-  def keys(*args, &block); end
+  def keys(*_arg0, &_arg1); end
   def model; end
   def returning; end
-  def skip_duplicates?(*args, &block); end
+  def skip_duplicates?(*_arg0, &_arg1); end
   def touch_model_timestamps_unless(&block); end
   def updatable_columns; end
-  def update_duplicates?(*args, &block); end
+  def update_duplicates?(*_arg0, &_arg1); end
   def values_list; end
 
   private
@@ -3310,9 +3560,7 @@ class ActiveRecord::InternalMetadata < ::ActiveRecord::Base
   class << self
     def [](key); end
     def []=(key, value); end
-    def _internal?; end
     def _validators; end
-    def attribute_type_decorations; end
     def create_table; end
     def defined_enums; end
     def drop_table; end
@@ -3326,7 +3574,18 @@ class ActiveRecord::InvalidForeignKey < ::ActiveRecord::WrappedDatabaseException
 end
 
 class ActiveRecord::InverseOfAssociationNotFoundError < ::ActiveRecord::ActiveRecordError
+  include(::DidYouMean::Correctable)
+
   def initialize(reflection = T.unsafe(nil), associated_class = T.unsafe(nil)); end
+
+  def associated_class; end
+  def reflection; end
+end
+
+class ActiveRecord::InverseOfAssociationNotFoundError::Correction
+  def initialize(error); end
+
+  def corrections; end
 end
 
 class ActiveRecord::IrreversibleOrderError < ::ActiveRecord::ActiveRecordError
@@ -3362,6 +3621,10 @@ class ActiveRecord::Locking::LockingType
   def encode_with(coder); end
   def init_with(coder); end
   def serialize(value); end
+
+  class << self
+    def new(subtype); end
+  end
 end
 
 module ActiveRecord::Locking::Optimistic
@@ -3369,26 +3632,25 @@ module ActiveRecord::Locking::Optimistic
 
   mixes_in_class_methods(::ActiveRecord::Locking::Optimistic::ClassMethods)
 
+  def increment!(*_arg0, **_arg1); end
   def locking_enabled?; end
 
   private
 
   def _create_record(attribute_names = T.unsafe(nil)); end
+  def _lock_value_for_database(locking_column); end
   def _touch_row(attribute_names, time); end
   def _update_row(attribute_names, attempted_action = T.unsafe(nil)); end
   def destroy_row; end
 end
 
 module ActiveRecord::Locking::Optimistic::ClassMethods
+  def define_attribute(name, cast_type, **_arg2); end
   def locking_column; end
   def locking_column=(value); end
   def locking_enabled?; end
   def reset_locking_column; end
   def update_counters(id, counters); end
-
-  private
-
-  def inherited(subclass); end
 end
 
 ActiveRecord::Locking::Optimistic::ClassMethods::DEFAULT_LOCKING_COLUMN = T.let(T.unsafe(nil), String)
@@ -3400,9 +3662,10 @@ end
 
 class ActiveRecord::LogSubscriber < ::ActiveSupport::LogSubscriber
   def backtrace_cleaner; end
-  def backtrace_cleaner=(_); end
+  def backtrace_cleaner=(_arg0); end
   def backtrace_cleaner?; end
   def sql(event); end
+  def strict_loading_violation(event); end
 
   private
 
@@ -3498,7 +3761,7 @@ class ActiveRecord::Migration
   def method_missing(method, *arguments, &block); end
   def migrate(direction); end
   def name; end
-  def name=(_); end
+  def name=(_arg0); end
   def next_migration_number(number); end
   def proper_table_name(name, options = T.unsafe(nil)); end
   def reversible; end
@@ -3514,7 +3777,7 @@ class ActiveRecord::Migration
   def verbose; end
   def verbose=(val); end
   def version; end
-  def version=(_); end
+  def version=(_arg0); end
   def write(text = T.unsafe(nil)); end
 
   private
@@ -3527,10 +3790,10 @@ class ActiveRecord::Migration
     def check_pending!(connection = T.unsafe(nil)); end
     def current_version; end
     def delegate; end
-    def delegate=(_); end
+    def delegate=(_arg0); end
     def disable_ddl_transaction; end
     def disable_ddl_transaction!; end
-    def disable_ddl_transaction=(_); end
+    def disable_ddl_transaction=(_arg0); end
     def inherited(subclass); end
     def load_schema_if_pending!; end
     def maintain_test_schema!; end
@@ -3560,6 +3823,7 @@ class ActiveRecord::Migration::CommandRecorder
   def initialize(delegate = T.unsafe(nil)); end
 
   def add_belongs_to(*args, &block); end
+  def add_check_constraint(*args, &block); end
   def add_column(*args, &block); end
   def add_foreign_key(*args, &block); end
   def add_index(*args, &block); end
@@ -3572,11 +3836,11 @@ class ActiveRecord::Migration::CommandRecorder
   def change_table(table_name, **options); end
   def change_table_comment(*args, &block); end
   def commands; end
-  def commands=(_); end
+  def commands=(_arg0); end
   def create_join_table(*args, &block); end
   def create_table(*args, &block); end
   def delegate; end
-  def delegate=(_); end
+  def delegate=(_arg0); end
   def disable_extension(*args, &block); end
   def drop_join_table(*args, &block); end
   def drop_table(*args, &block); end
@@ -3588,6 +3852,7 @@ class ActiveRecord::Migration::CommandRecorder
   def invert_remove_belongs_to(args, &block); end
   def record(*command, &block); end
   def remove_belongs_to(*args, &block); end
+  def remove_check_constraint(*args, &block); end
   def remove_column(*args, &block); end
   def remove_columns(*args, &block); end
   def remove_foreign_key(*args, &block); end
@@ -3600,17 +3865,17 @@ class ActiveRecord::Migration::CommandRecorder
   def replay(migration); end
   def revert; end
   def reverting; end
-  def reverting=(_); end
+  def reverting=(_arg0); end
   def transaction(*args, &block); end
 
   private
 
-  def invert_add_index(args); end
   def invert_change_column_comment(args); end
   def invert_change_column_default(args); end
   def invert_change_column_null(args); end
   def invert_change_table_comment(args); end
   def invert_drop_table(args, &block); end
+  def invert_remove_check_constraint(args); end
   def invert_remove_column(args); end
   def invert_remove_columns(args); end
   def invert_remove_foreign_key(args); end
@@ -3626,8 +3891,10 @@ end
 ActiveRecord::Migration::CommandRecorder::ReversibleAndIrreversibleMethods = T.let(T.unsafe(nil), Array)
 
 module ActiveRecord::Migration::CommandRecorder::StraightReversions
+  def invert_add_check_constraint(args, &block); end
   def invert_add_column(args, &block); end
   def invert_add_foreign_key(args, &block); end
+  def invert_add_index(args, &block); end
   def invert_add_reference(args, &block); end
   def invert_add_timestamps(args, &block); end
   def invert_create_join_table(args, &block); end
@@ -3637,8 +3904,10 @@ module ActiveRecord::Migration::CommandRecorder::StraightReversions
   def invert_drop_table(args, &block); end
   def invert_enable_extension(args, &block); end
   def invert_execute_block(args, &block); end
+  def invert_remove_check_constraint(args, &block); end
   def invert_remove_column(args, &block); end
   def invert_remove_foreign_key(args, &block); end
+  def invert_remove_index(args, &block); end
   def invert_remove_reference(args, &block); end
   def invert_remove_timestamps(args, &block); end
 end
@@ -3653,18 +3922,18 @@ class ActiveRecord::Migration::Compatibility::V4_2 < ::ActiveRecord::Migration::
   def add_belongs_to(table_name, ref_name, **options); end
   def add_reference(table_name, ref_name, **options); end
   def add_timestamps(table_name, **options); end
-  def index_exists?(table_name, column_name, options = T.unsafe(nil)); end
-  def remove_index(table_name, options = T.unsafe(nil)); end
+  def index_exists?(table_name, column_name, **options); end
+  def remove_index(table_name, column_name = T.unsafe(nil), **options); end
 
   private
 
   def compatible_table_definition(t); end
-  def index_name_for_remove(table_name, options = T.unsafe(nil)); end
+  def index_name_for_remove(table_name, column_name, options); end
 end
 
 module ActiveRecord::Migration::Compatibility::V4_2::TableDefinition
-  def belongs_to(*_, **options); end
-  def references(*_, **options); end
+  def belongs_to(*_arg0, **options); end
+  def references(*_arg0, **options); end
   def timestamps(**options); end
 end
 
@@ -3687,7 +3956,7 @@ module ActiveRecord::Migration::Compatibility::V5_0::TableDefinition
 end
 
 class ActiveRecord::Migration::Compatibility::V5_1 < ::ActiveRecord::Migration::Compatibility::V5_2
-  def change_column(table_name, column_name, type, options = T.unsafe(nil)); end
+  def change_column(table_name, column_name, type, **options); end
   def create_table(table_name, **options); end
 end
 
@@ -3713,10 +3982,31 @@ module ActiveRecord::Migration::Compatibility::V5_2::TableDefinition
   def timestamps(**options); end
 end
 
-class ActiveRecord::Migration::Compatibility::V6_0 < ::ActiveRecord::Migration::Current
+class ActiveRecord::Migration::Compatibility::V6_0 < ::ActiveRecord::Migration::Compatibility::V6_1
+  def add_belongs_to(table_name, ref_name, **options); end
+  def add_reference(table_name, ref_name, **options); end
+  def change_table(table_name, **options); end
+  def create_join_table(table_1, table_2, **options); end
+  def create_table(table_name, **options); end
+
+  private
+
+  def compatible_table_definition(t); end
+end
+
+class ActiveRecord::Migration::Compatibility::V6_0::ReferenceDefinition < ::ActiveRecord::ConnectionAdapters::ReferenceDefinition
+  def index_options(table_name); end
+end
+
+module ActiveRecord::Migration::Compatibility::V6_0::TableDefinition
+  def belongs_to(*args, **options); end
+  def references(*args, **options); end
+end
+
+class ActiveRecord::Migration::Compatibility::V6_1 < ::ActiveRecord::Migration::Current
 end
 
-ActiveRecord::Migration::Compatibility::V6_1 = ActiveRecord::Migration::Current
+ActiveRecord::Migration::Compatibility::V7_0 = ActiveRecord::Migration::Current
 
 class ActiveRecord::Migration::Current < ::ActiveRecord::Migration
 end
@@ -3738,10 +4028,10 @@ class ActiveRecord::Migration::ReversibleBlockHelper < ::Struct
   def up; end
 
   class << self
-    def [](*_); end
+    def [](*_arg0); end
     def inspect; end
     def members; end
-    def new(*_); end
+    def new(*_arg0); end
   end
 end
 
@@ -3779,11 +4069,12 @@ class ActiveRecord::Migrator
   def use_transaction?(migration); end
   def validate(migrations); end
   def with_advisory_lock; end
+  def with_advisory_lock_connection; end
 
   class << self
     def current_version; end
     def migrations_paths; end
-    def migrations_paths=(_); end
+    def migrations_paths=(_arg0); end
   end
 end
 
@@ -3806,6 +4097,7 @@ module ActiveRecord::ModelSchema::ClassMethods
   def attribute_types; end
   def attributes_builder; end
   def column_defaults; end
+  def column_for_attribute(name); end
   def column_names; end
   def columns; end
   def columns_hash; end
@@ -3839,6 +4131,7 @@ module ActiveRecord::ModelSchema::ClassMethods
 
   private
 
+  def _convert_type_from_options(type); end
   def compute_table_name; end
   def inherited(child_class); end
   def load_schema; end
@@ -3846,6 +4139,7 @@ module ActiveRecord::ModelSchema::ClassMethods
   def reload_schema_from_cache; end
   def schema_loaded?; end
   def undecorated_table_name(class_name = T.unsafe(nil)); end
+  def warn_if_deprecated_type(column); end
 end
 
 class ActiveRecord::MultiparameterAssignmentErrors < ::ActiveRecord::ActiveRecordError
@@ -3899,8 +4193,8 @@ module ActiveRecord::NoTouching
   mixes_in_class_methods(::ActiveRecord::NoTouching::ClassMethods)
 
   def no_touching?; end
-  def touch(*_, **_); end
-  def touch_later(*_); end
+  def touch(*_arg0, **_arg1); end
+  def touch_later(*_arg0); end
 
   class << self
     def applied_to?(klass); end
@@ -3966,8 +4260,6 @@ module ActiveRecord::Persistence
   def update(attributes); end
   def update!(attributes); end
   def update_attribute(name, value); end
-  def update_attributes(*args, &block); end
-  def update_attributes!(*args, &block); end
   def update_column(name, value); end
   def update_columns(attributes); end
 
@@ -3975,14 +4267,17 @@ module ActiveRecord::Persistence
 
   def _create_record(attribute_names = T.unsafe(nil)); end
   def _delete_row; end
+  def _find_record(options); end
+  def _primary_key_constraints_hash; end
   def _raise_readonly_record_error; end
   def _raise_record_not_destroyed; end
   def _raise_record_not_touched_error; end
   def _touch_row(attribute_names, time); end
   def _update_record(attribute_names = T.unsafe(nil)); end
   def _update_row(attribute_names, attempted_action = T.unsafe(nil)); end
+  def apply_scoping?(options); end
   def belongs_to_touch_method; end
-  def create_or_update(**_, &block); end
+  def create_or_update(**_arg0, &block); end
   def destroy_associations; end
   def destroy_row; end
   def verify_readonly_attribute(name); end
@@ -4007,7 +4302,6 @@ module ActiveRecord::Persistence::ClassMethods
 
   private
 
-  def _substitute_values(values); end
   def discriminate_class_for_record(record); end
   def instantiate_instance_of(klass, attributes, column_types = T.unsafe(nil), &block); end
 end
@@ -4015,19 +4309,21 @@ end
 class ActiveRecord::PredicateBuilder
   def initialize(table); end
 
-  def build(attribute, value); end
+  def [](attr_name, value, operator = T.unsafe(nil)); end
+  def build(attribute, value, operator = T.unsafe(nil)); end
   def build_bind_attribute(column_name, value); end
-  def build_from_hash(attributes); end
+  def build_from_hash(attributes, &block); end
   def register_handler(klass, handler); end
-  def resolve_arel_attribute(table_name, column_name); end
+  def resolve_arel_attribute(table_name, column_name, &block); end
 
   protected
 
-  def expand_from_hash(attributes); end
+  def expand_from_hash(attributes, &block); end
 
   private
 
   def convert_dot_notation_to_hash(attributes); end
+  def grouping_queries(queries); end
   def handler_for(object); end
   def table; end
 
@@ -4066,16 +4362,6 @@ class ActiveRecord::PredicateBuilder::AssociationQueryValue
   def value; end
 end
 
-class ActiveRecord::PredicateBuilder::BaseHandler
-  def initialize(predicate_builder); end
-
-  def call(attribute, value); end
-
-  private
-
-  def predicate_builder; end
-end
-
 class ActiveRecord::PredicateBuilder::BasicObjectHandler
   def initialize(predicate_builder); end
 
@@ -4119,10 +4405,10 @@ class ActiveRecord::PredicateBuilder::RangeHandler::RangeWithBinds < ::Struct
   def exclude_end?; end
 
   class << self
-    def [](*_); end
+    def [](*_arg0); end
     def inspect; end
     def members; end
-    def new(*_); end
+    def new(*_arg0); end
   end
 end
 
@@ -4157,9 +4443,10 @@ end
 
 module ActiveRecord::QueryMethods
   include(::ActiveModel::ForbiddenAttributesProtection)
-  extend(::ActiveSupport::Concern)
 
   def _select!(*fields); end
+  def and(other); end
+  def and!(other); end
   def annotate(*args); end
   def annotate!(*args); end
   def annotate_values; end
@@ -4178,6 +4465,8 @@ module ActiveRecord::QueryMethods
   def eager_load!(*args); end
   def eager_load_values; end
   def eager_load_values=(value); end
+  def excluding(*records); end
+  def excluding!(records); end
   def extending(*modules, &block); end
   def extending!(*modules, &block); end
   def extending_values; end
@@ -4200,6 +4489,8 @@ module ActiveRecord::QueryMethods
   def includes!(*args); end
   def includes_values; end
   def includes_values=(value); end
+  def invert_where; end
+  def invert_where!; end
   def joins(*args); end
   def joins!(*args); end
   def joins_values; end
@@ -4267,19 +4558,22 @@ module ActiveRecord::QueryMethods
   def strict_loading!(value = T.unsafe(nil)); end
   def strict_loading_value; end
   def strict_loading_value=(value); end
+  def uniq!(name); end
   def unscope(*args); end
   def unscope!(*args); end
   def unscope_values; end
   def unscope_values=(value); end
-  def where(opts = T.unsafe(nil), *rest); end
+  def where(*args); end
   def where!(opts, *rest); end
   def where_clause; end
   def where_clause=(value); end
+  def without(*records); end
 
   protected
 
+  def build_having_clause(opts, rest = T.unsafe(nil)); end
   def build_subquery(subquery_alias, select_value); end
-  def build_where_clause(opts, *rest); end
+  def build_where_clause(opts, rest = T.unsafe(nil)); end
 
   private
 
@@ -4289,141 +4583,143 @@ module ActiveRecord::QueryMethods
   def build_arel(aliases); end
   def build_cast_value(name, value); end
   def build_from; end
-  def build_join_query(manager, buckets, join_type, aliases); end
-  def build_joins(manager, joins, aliases); end
-  def build_left_outer_joins(manager, outer_joins, aliases); end
+  def build_join_buckets; end
+  def build_join_dependencies; end
+  def build_joins(join_sources, aliases = T.unsafe(nil)); end
   def build_order(arel); end
   def build_select(arel); end
-  def check_if_method_has_arguments!(method_name, args); end
+  def check_if_method_has_arguments!(method_name, args, message = T.unsafe(nil)); end
   def column_references(order_args); end
   def does_not_support_reverse?(order); end
-  def having_clause_factory; end
+  def each_join_dependencies(join_dependencies = T.unsafe(nil)); end
+  def lookup_table_klass_from_join_dependencies(table_name); end
   def order_column(field); end
   def preprocess_order_args(order_args); end
   def resolve_arel_attributes(attrs); end
   def reverse_sql_order(order_query); end
   def sanitize_order_arguments(order_args); end
-  def select_association_list(associations); end
-  def structurally_incompatible_values_for_or(other); end
+  def select_association_list(associations, stashed_joins = T.unsafe(nil)); end
+  def structurally_incompatible_values_for(other); end
   def table_name_matches?(from); end
-  def valid_association_list(associations); end
   def validate_order_args(args); end
-  def where_clause_factory; end
 end
 
 ActiveRecord::QueryMethods::FROZEN_EMPTY_ARRAY = T.let(T.unsafe(nil), Array)
 
 ActiveRecord::QueryMethods::FROZEN_EMPTY_HASH = T.let(T.unsafe(nil), Hash)
 
-ActiveRecord::QueryMethods::STRUCTURAL_OR_METHODS = T.let(T.unsafe(nil), Array)
+ActiveRecord::QueryMethods::STRUCTURAL_VALUE_METHODS = T.let(T.unsafe(nil), Array)
 
 ActiveRecord::QueryMethods::VALID_DIRECTIONS = T.let(T.unsafe(nil), Set)
 
 ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES = T.let(T.unsafe(nil), Set)
 
 class ActiveRecord::QueryMethods::WhereChain
-  include(::ActiveModel::ForbiddenAttributesProtection)
-
   def initialize(scope); end
 
-  def missing(*args); end
+  def associated(*associations); end
+  def missing(*associations); end
   def not(opts, *rest); end
-
-  private
-
-  def not_behaves_as_nor?(opts); end
 end
 
 module ActiveRecord::Querying
-  def annotate(*args, &block); end
-  def any?(*args, &block); end
-  def average(*args, &block); end
-  def calculate(*args, &block); end
-  def count(*args, &block); end
+  def _load_from_sql(result_set, &block); end
+  def _query_by_sql(sql, binds = T.unsafe(nil), preparable: T.unsafe(nil), async: T.unsafe(nil)); end
+  def and(*_arg0, &_arg1); end
+  def annotate(*_arg0, &_arg1); end
+  def any?(*_arg0, &_arg1); end
+  def average(*_arg0, &_arg1); end
+  def calculate(*_arg0, &_arg1); end
+  def count(*_arg0, &_arg1); end
   def count_by_sql(sql); end
-  def create_or_find_by(*args, &block); end
-  def create_or_find_by!(*args, &block); end
-  def create_with(*args, &block); end
-  def delete_all(*args, &block); end
-  def delete_by(*args, &block); end
-  def destroy_all(*args, &block); end
-  def destroy_by(*args, &block); end
-  def distinct(*args, &block); end
-  def eager_load(*args, &block); end
-  def except(*args, &block); end
-  def exists?(*args, &block); end
-  def extending(*args, &block); end
-  def extract_associated(*args, &block); end
-  def fifth(*args, &block); end
-  def fifth!(*args, &block); end
-  def find(*args, &block); end
-  def find_by(*args, &block); end
-  def find_by!(*args, &block); end
+  def create_or_find_by(*_arg0, &_arg1); end
+  def create_or_find_by!(*_arg0, &_arg1); end
+  def create_with(*_arg0, &_arg1); end
+  def delete_all(*_arg0, &_arg1); end
+  def delete_by(*_arg0, &_arg1); end
+  def destroy_all(*_arg0, &_arg1); end
+  def destroy_by(*_arg0, &_arg1); end
+  def distinct(*_arg0, &_arg1); end
+  def eager_load(*_arg0, &_arg1); end
+  def except(*_arg0, &_arg1); end
+  def excluding(*_arg0, &_arg1); end
+  def exists?(*_arg0, &_arg1); end
+  def extending(*_arg0, &_arg1); end
+  def extract_associated(*_arg0, &_arg1); end
+  def fifth(*_arg0, &_arg1); end
+  def fifth!(*_arg0, &_arg1); end
+  def find(*_arg0, &_arg1); end
+  def find_by(*_arg0, &_arg1); end
+  def find_by!(*_arg0, &_arg1); end
   def find_by_sql(sql, binds = T.unsafe(nil), preparable: T.unsafe(nil), &block); end
-  def find_each(*args, &block); end
-  def find_in_batches(*args, &block); end
-  def find_or_create_by(*args, &block); end
-  def find_or_create_by!(*args, &block); end
-  def find_or_initialize_by(*args, &block); end
-  def first(*args, &block); end
-  def first!(*args, &block); end
-  def first_or_create(*args, &block); end
-  def first_or_create!(*args, &block); end
-  def first_or_initialize(*args, &block); end
-  def forty_two(*args, &block); end
-  def forty_two!(*args, &block); end
-  def fourth(*args, &block); end
-  def fourth!(*args, &block); end
-  def from(*args, &block); end
-  def group(*args, &block); end
-  def having(*args, &block); end
-  def ids(*args, &block); end
-  def in_batches(*args, &block); end
-  def includes(*args, &block); end
-  def joins(*args, &block); end
-  def last(*args, &block); end
-  def last!(*args, &block); end
-  def left_joins(*args, &block); end
-  def left_outer_joins(*args, &block); end
-  def limit(*args, &block); end
-  def lock(*args, &block); end
-  def many?(*args, &block); end
-  def maximum(*args, &block); end
-  def merge(*args, &block); end
-  def minimum(*args, &block); end
-  def none(*args, &block); end
-  def none?(*args, &block); end
-  def offset(*args, &block); end
-  def one?(*args, &block); end
-  def only(*args, &block); end
-  def optimizer_hints(*args, &block); end
-  def or(*args, &block); end
-  def order(*args, &block); end
-  def pick(*args, &block); end
-  def pluck(*args, &block); end
-  def preload(*args, &block); end
-  def readonly(*args, &block); end
-  def references(*args, &block); end
-  def reorder(*args, &block); end
-  def reselect(*args, &block); end
-  def rewhere(*args, &block); end
-  def second(*args, &block); end
-  def second!(*args, &block); end
-  def second_to_last(*args, &block); end
-  def second_to_last!(*args, &block); end
-  def select(*args, &block); end
-  def strict_loading(*args, &block); end
-  def sum(*args, &block); end
-  def take(*args, &block); end
-  def take!(*args, &block); end
-  def third(*args, &block); end
-  def third!(*args, &block); end
-  def third_to_last(*args, &block); end
-  def third_to_last!(*args, &block); end
-  def touch_all(*args, &block); end
-  def unscope(*args, &block); end
-  def update_all(*args, &block); end
-  def where(*args, &block); end
+  def find_each(*_arg0, &_arg1); end
+  def find_in_batches(*_arg0, &_arg1); end
+  def find_or_create_by(*_arg0, &_arg1); end
+  def find_or_create_by!(*_arg0, &_arg1); end
+  def find_or_initialize_by(*_arg0, &_arg1); end
+  def find_sole_by(*_arg0, &_arg1); end
+  def first(*_arg0, &_arg1); end
+  def first!(*_arg0, &_arg1); end
+  def first_or_create(*_arg0, &_arg1); end
+  def first_or_create!(*_arg0, &_arg1); end
+  def first_or_initialize(*_arg0, &_arg1); end
+  def forty_two(*_arg0, &_arg1); end
+  def forty_two!(*_arg0, &_arg1); end
+  def fourth(*_arg0, &_arg1); end
+  def fourth!(*_arg0, &_arg1); end
+  def from(*_arg0, &_arg1); end
+  def group(*_arg0, &_arg1); end
+  def having(*_arg0, &_arg1); end
+  def ids(*_arg0, &_arg1); end
+  def in_batches(*_arg0, &_arg1); end
+  def includes(*_arg0, &_arg1); end
+  def invert_where(*_arg0, &_arg1); end
+  def joins(*_arg0, &_arg1); end
+  def last(*_arg0, &_arg1); end
+  def last!(*_arg0, &_arg1); end
+  def left_joins(*_arg0, &_arg1); end
+  def left_outer_joins(*_arg0, &_arg1); end
+  def limit(*_arg0, &_arg1); end
+  def lock(*_arg0, &_arg1); end
+  def many?(*_arg0, &_arg1); end
+  def maximum(*_arg0, &_arg1); end
+  def merge(*_arg0, &_arg1); end
+  def minimum(*_arg0, &_arg1); end
+  def none(*_arg0, &_arg1); end
+  def none?(*_arg0, &_arg1); end
+  def offset(*_arg0, &_arg1); end
+  def one?(*_arg0, &_arg1); end
+  def only(*_arg0, &_arg1); end
+  def optimizer_hints(*_arg0, &_arg1); end
+  def or(*_arg0, &_arg1); end
+  def order(*_arg0, &_arg1); end
+  def pick(*_arg0, &_arg1); end
+  def pluck(*_arg0, &_arg1); end
+  def preload(*_arg0, &_arg1); end
+  def readonly(*_arg0, &_arg1); end
+  def references(*_arg0, &_arg1); end
+  def reorder(*_arg0, &_arg1); end
+  def reselect(*_arg0, &_arg1); end
+  def rewhere(*_arg0, &_arg1); end
+  def second(*_arg0, &_arg1); end
+  def second!(*_arg0, &_arg1); end
+  def second_to_last(*_arg0, &_arg1); end
+  def second_to_last!(*_arg0, &_arg1); end
+  def select(*_arg0, &_arg1); end
+  def sole(*_arg0, &_arg1); end
+  def strict_loading(*_arg0, &_arg1); end
+  def sum(*_arg0, &_arg1); end
+  def take(*_arg0, &_arg1); end
+  def take!(*_arg0, &_arg1); end
+  def third(*_arg0, &_arg1); end
+  def third!(*_arg0, &_arg1); end
+  def third_to_last(*_arg0, &_arg1); end
+  def third_to_last!(*_arg0, &_arg1); end
+  def touch_all(*_arg0, &_arg1); end
+  def unscope(*_arg0, &_arg1); end
+  def update_all(*_arg0, &_arg1); end
+  def where(*_arg0, &_arg1); end
+  def without(*_arg0, &_arg1); end
 end
 
 ActiveRecord::Querying::QUERYING_METHODS = T.let(T.unsafe(nil), Array)
@@ -4500,24 +4796,20 @@ end
 class ActiveRecord::Reflection::AbstractReflection
   def alias_candidate(name); end
   def build_association(attributes, &block); end
-  def build_scope(table, predicate_builder = T.unsafe(nil)); end
+  def build_scope(table, predicate_builder = T.unsafe(nil), klass = T.unsafe(nil)); end
   def chain; end
   def check_validity_of_inverse!; end
   def class_name; end
   def constraints; end
   def counter_cache_column; end
   def counter_must_be_updated_by_has_many?; end
-  def get_join_keys(association_klass); end
   def has_cached_counter?; end
   def inverse_of; end
   def inverse_updates_counter_cache?; end
   def inverse_updates_counter_in_memory?; end
   def inverse_which_updates_counter_cache; end
-  def join_foreign_key; end
-  def join_keys; end
-  def join_primary_key(*_); end
   def join_scope(table, foreign_table, foreign_klass); end
-  def join_scopes(table, predicate_builder); end
+  def join_scopes(table, predicate_builder, klass = T.unsafe(nil)); end
   def klass_join_scope(table, predicate_builder); end
   def scopes; end
   def strict_loading?; end
@@ -4530,24 +4822,11 @@ class ActiveRecord::Reflection::AbstractReflection
 
   private
 
+  def ensure_option_not_given_as_class!(option_name); end
   def predicate_builder(table); end
   def primary_key(klass); end
 end
 
-class ActiveRecord::Reflection::AbstractReflection::JoinKeys < ::Struct
-  def foreign_key; end
-  def foreign_key=(_); end
-  def key; end
-  def key=(_); end
-
-  class << self
-    def [](*_); end
-    def inspect; end
-    def members; end
-    def new(*_); end
-  end
-end
-
 class ActiveRecord::Reflection::AggregateReflection < ::ActiveRecord::Reflection::MacroReflection
   def mapping; end
 end
@@ -4562,7 +4841,7 @@ class ActiveRecord::Reflection::AssociationReflection < ::ActiveRecord::Reflecti
   def association_class; end
   def association_foreign_key; end
   def association_primary_key(klass = T.unsafe(nil)); end
-  def association_scope_cache(conn, owner, &block); end
+  def association_scope_cache(klass, owner, &block); end
   def belongs_to?; end
   def check_eager_loadable!; end
   def check_preloadable!; end
@@ -4571,19 +4850,20 @@ class ActiveRecord::Reflection::AssociationReflection < ::ActiveRecord::Reflecti
   def collect_join_chain; end
   def collection?; end
   def compute_class(name); end
-  def constructable?; end
   def extensions; end
   def foreign_key; end
   def foreign_type; end
   def has_inverse?; end
   def has_one?; end
   def has_scope?; end
+  def join_foreign_key; end
   def join_id_for(owner); end
+  def join_primary_key(klass = T.unsafe(nil)); end
   def join_table; end
   def macro; end
   def nested?; end
   def parent_reflection; end
-  def parent_reflection=(_); end
+  def parent_reflection=(_arg0); end
   def polymorphic?; end
   def polymorphic_inverse_of(associated_class); end
   def source_reflection; end
@@ -4594,7 +4874,6 @@ class ActiveRecord::Reflection::AssociationReflection < ::ActiveRecord::Reflecti
   private
 
   def automatic_inverse_of; end
-  def calculate_constructable(macro, options); end
   def can_find_inverse_of_automatically?(reflection); end
   def derive_class_name; end
   def derive_foreign_key; end
@@ -4603,20 +4882,17 @@ class ActiveRecord::Reflection::AssociationReflection < ::ActiveRecord::Reflecti
   def valid_inverse_reflection?(reflection); end
 end
 
-ActiveRecord::Reflection::AssociationReflection::INVALID_AUTOMATIC_INVERSE_OPTIONS = T.let(T.unsafe(nil), Array)
-
-ActiveRecord::Reflection::AssociationReflection::VALID_AUTOMATIC_INVERSE_MACROS = T.let(T.unsafe(nil), Array)
-
 class ActiveRecord::Reflection::BelongsToReflection < ::ActiveRecord::Reflection::AssociationReflection
   def association_class; end
+  def association_primary_key(klass = T.unsafe(nil)); end
   def belongs_to?; end
   def join_foreign_key; end
+  def join_foreign_type; end
   def join_primary_key(klass = T.unsafe(nil)); end
   def macro; end
 
   private
 
-  def calculate_constructable(macro, options); end
   def can_find_inverse_of_automatically?(_); end
 end
 
@@ -4638,7 +4914,6 @@ end
 
 class ActiveRecord::Reflection::HasManyReflection < ::ActiveRecord::Reflection::AssociationReflection
   def association_class; end
-  def association_primary_key(klass = T.unsafe(nil)); end
   def collection?; end
   def macro; end
 end
@@ -4647,10 +4922,6 @@ class ActiveRecord::Reflection::HasOneReflection < ::ActiveRecord::Reflection::A
   def association_class; end
   def has_one?; end
   def macro; end
-
-  private
-
-  def calculate_constructable(macro, options); end
 end
 
 class ActiveRecord::Reflection::MacroReflection < ::ActiveRecord::Reflection::AbstractReflection
@@ -4676,13 +4947,15 @@ class ActiveRecord::Reflection::PolymorphicReflection < ::ActiveRecord::Reflecti
   def initialize(reflection, previous_reflection); end
 
   def constraints; end
-  def get_join_keys(*args, &block); end
-  def join_scopes(table, predicate_builder); end
-  def klass(*args, &block); end
-  def plural_name(*args, &block); end
-  def scope(*args, &block); end
-  def scope_for(*args, &block); end
-  def type(*args, &block); end
+  def join_foreign_key(*_arg0, &_arg1); end
+  def join_primary_key(*_arg0, &_arg1); end
+  def join_scopes(table, predicate_builder, klass = T.unsafe(nil)); end
+  def klass(*_arg0, &_arg1); end
+  def name(*_arg0, &_arg1); end
+  def plural_name(*_arg0, &_arg1); end
+  def scope(*_arg0, &_arg1); end
+  def scope_for(*_arg0, &_arg1); end
+  def type(*_arg0, &_arg1); end
 
   private
 
@@ -4694,58 +4967,59 @@ class ActiveRecord::Reflection::RuntimeReflection < ::ActiveRecord::Reflection::
 
   def aliased_table; end
   def all_includes; end
-  def constraints(*args, &block); end
-  def get_join_keys(*args, &block); end
+  def constraints(*_arg0, &_arg1); end
+  def join_foreign_key(*_arg0, &_arg1); end
+  def join_primary_key(klass = T.unsafe(nil)); end
   def klass; end
-  def scope(*args, &block); end
-  def type(*args, &block); end
+  def scope(*_arg0, &_arg1); end
+  def type(*_arg0, &_arg1); end
 end
 
 class ActiveRecord::Reflection::ThroughReflection < ::ActiveRecord::Reflection::AbstractReflection
   def initialize(delegate_reflection); end
 
-  def active_record(*args, &block); end
-  def active_record_primary_key(*args, &block); end
+  def active_record(*_arg0, &_arg1); end
+  def active_record_primary_key(*_arg0, &_arg1); end
   def add_as_polymorphic_through(reflection, seed); end
   def add_as_source(seed); end
   def add_as_through(seed); end
-  def association_class(*args, &block); end
-  def association_foreign_key(*args, &block); end
+  def association_class(*_arg0, &_arg1); end
+  def association_foreign_key(*_arg0, &_arg1); end
   def association_primary_key(klass = T.unsafe(nil)); end
-  def association_scope_cache(*args, &block); end
+  def association_scope_cache(*_arg0, &_arg1); end
   def autosave=(arg); end
-  def belongs_to?(*args, &block); end
-  def check_eager_loadable!(*args, &block); end
-  def check_preloadable!(*args, &block); end
+  def belongs_to?(*_arg0, &_arg1); end
+  def check_eager_loadable!(*_arg0, &_arg1); end
+  def check_preloadable!(*_arg0, &_arg1); end
   def check_validity!; end
   def clear_association_scope_cache; end
   def collect_join_chain; end
-  def collection?(*args, &block); end
-  def compute_class(*args, &block); end
+  def collection?(*_arg0, &_arg1); end
+  def compute_class(*_arg0, &_arg1); end
   def constraints; end
-  def constructable?(*args, &block); end
-  def extensions(*args, &block); end
-  def foreign_key(*args, &block); end
-  def foreign_type(*args, &block); end
-  def get_join_keys(*args, &block); end
-  def has_inverse?(*args, &block); end
-  def has_one?(*args, &block); end
+  def extensions(*_arg0, &_arg1); end
+  def foreign_key(*_arg0, &_arg1); end
+  def foreign_type(*_arg0, &_arg1); end
+  def has_inverse?(*_arg0, &_arg1); end
+  def has_one?(*_arg0, &_arg1); end
   def has_scope?; end
-  def join_id_for(*args, &block); end
-  def join_scopes(table, predicate_builder); end
-  def join_table(*args, &block); end
+  def join_foreign_key(*_arg0, &_arg1); end
+  def join_id_for(*_arg0, &_arg1); end
+  def join_primary_key(klass = T.unsafe(nil)); end
+  def join_scopes(table, predicate_builder, klass = T.unsafe(nil)); end
+  def join_table(*_arg0, &_arg1); end
   def klass; end
-  def macro(*args, &block); end
-  def name(*args, &block); end
+  def macro(*_arg0, &_arg1); end
+  def name(*_arg0, &_arg1); end
   def nested?; end
-  def options(*args, &block); end
-  def parent_reflection(*args, &block); end
+  def options(*_arg0, &_arg1); end
+  def parent_reflection(*_arg0, &_arg1); end
   def parent_reflection=(arg); end
-  def plural_name(*args, &block); end
-  def polymorphic?(*args, &block); end
-  def polymorphic_inverse_of(*args, &block); end
-  def scope(*args, &block); end
-  def scope_for(*args, &block); end
+  def plural_name(*_arg0, &_arg1); end
+  def polymorphic?(*_arg0, &_arg1); end
+  def polymorphic_inverse_of(*_arg0, &_arg1); end
+  def scope(*_arg0, &_arg1); end
+  def scope_for(*_arg0, &_arg1); end
   def scopes; end
   def source_options; end
   def source_reflection; end
@@ -4754,8 +5028,8 @@ class ActiveRecord::Reflection::ThroughReflection < ::ActiveRecord::Reflection::
   def through_options; end
   def through_reflection; end
   def through_reflection?; end
-  def type(*args, &block); end
-  def validate?(*args, &block); end
+  def type(*_arg0, &_arg1); end
+  def validate?(*_arg0, &_arg1); end
 
   protected
 
@@ -4784,11 +5058,10 @@ class ActiveRecord::Relation
   def initialize(klass, table: T.unsafe(nil), predicate_builder: T.unsafe(nil), values: T.unsafe(nil)); end
 
   def ==(other); end
-  def _deprecated_scope_source; end
-  def _exec_scope(name, *args, &block); end
+  def _exec_scope(*args, &block); end
   def alias_tracker(joins = T.unsafe(nil), aliases = T.unsafe(nil)); end
   def any?; end
-  def arel_attribute(name); end
+  def arel_attribute(*args, &block); end
   def bind_attribute(name, value); end
   def blank?; end
   def build(attributes = T.unsafe(nil), &block); end
@@ -4819,6 +5092,7 @@ class ActiveRecord::Relation
   def joined_includes_values; end
   def klass; end
   def load(&block); end
+  def load_async; end
   def loaded; end
   def loaded?; end
   def locked?; end
@@ -4833,11 +5107,12 @@ class ActiveRecord::Relation
   def records; end
   def reload; end
   def reset; end
+  def scheduled?; end
   def scope_for_create; end
-  def scoping; end
+  def scoping(all_queries: T.unsafe(nil)); end
   def size; end
   def skip_preloading_value; end
-  def skip_preloading_value=(_); end
+  def skip_preloading_value=(_arg0); end
   def table; end
   def to_a; end
   def to_ary; end
@@ -4847,27 +5122,31 @@ class ActiveRecord::Relation
   def update_all(updates); end
   def update_counters(counters); end
   def values; end
+  def values_for_queries; end
   def where_values_hash(relation_table_name = T.unsafe(nil)); end
 
   protected
 
-  def _deprecated_scope_source=(_); end
   def load_records(records); end
   def null_relation?; end
 
   private
 
-  def _deprecated_scope_block(name, &block); end
-  def _deprecated_spawn(name); end
+  def _create(attributes, &block); end
+  def _create!(attributes, &block); end
   def _increment_attribute(attribute, value = T.unsafe(nil)); end
-  def _scoping(scope); end
+  def _new(attributes, &block); end
+  def _scoping(scope, all_queries = T.unsafe(nil)); end
   def _substitute_values(values); end
   def already_in_scope?; end
-  def build_preloader; end
   def compute_cache_key(timestamp_column = T.unsafe(nil)); end
   def compute_cache_version(timestamp_column); end
+  def current_scope_restoring_block(&block); end
+  def exec_main_query(async: T.unsafe(nil)); end
   def exec_queries(&block); end
+  def global_scope?; end
   def initialize_copy(other); end
+  def instantiate_records(rows, &block); end
   def references_eager_loaded_tables?; end
   def skip_query_cache_if_necessary; end
   def tables_in_string(string); end
@@ -4890,7 +5169,7 @@ class ActiveRecord::Relation::FromClause
 end
 
 class ActiveRecord::Relation::HashMerger
-  def initialize(relation, hash); end
+  def initialize(relation, hash, rewhere = T.unsafe(nil)); end
 
   def hash; end
   def merge; end
@@ -4903,10 +5182,9 @@ ActiveRecord::Relation::INVALID_METHODS_FOR_DELETE_ALL = T.let(T.unsafe(nil), Ar
 ActiveRecord::Relation::MULTI_VALUE_METHODS = T.let(T.unsafe(nil), Array)
 
 class ActiveRecord::Relation::Merger
-  def initialize(relation, other); end
+  def initialize(relation, other, rewhere = T.unsafe(nil)); end
 
   def merge; end
-  def normal_values; end
   def other; end
   def relation; end
   def values; end
@@ -4918,6 +5196,7 @@ class ActiveRecord::Relation::Merger
   def merge_multi_values; end
   def merge_outer_joins; end
   def merge_preloads; end
+  def merge_select_values; end
   def merge_single_values; end
   def replace_from_clause?; end
 end
@@ -4954,16 +5233,19 @@ class ActiveRecord::Relation::WhereClause
   def +(other); end
   def -(other); end
   def ==(other); end
-  def any?(*args, &block); end
+  def any?(*_arg0, &_arg1); end
   def ast; end
   def contradiction?; end
-  def each_attribute(&block); end
-  def empty?(*args, &block); end
+  def empty?(*_arg0, &_arg1); end
+  def eql?(other); end
   def except(*columns); end
-  def invert(as = T.unsafe(nil)); end
-  def merge(other); end
+  def extract_attributes; end
+  def hash; end
+  def invert; end
+  def merge(other, rewhere = T.unsafe(nil)); end
   def or(other); end
-  def to_h(table_name = T.unsafe(nil)); end
+  def to_h(table_name = T.unsafe(nil), equality_only: T.unsafe(nil)); end
+  def |(other); end
 
   protected
 
@@ -4972,9 +5254,11 @@ class ActiveRecord::Relation::WhereClause
 
   private
 
-  def equalities(predicates); end
+  def each_attributes; end
+  def equalities(predicates, equality_only); end
   def equality_node?(node); end
   def except_predicates(columns); end
+  def extract_attribute(node); end
   def extract_node_value(node); end
   def invert_predicate(node); end
   def non_empty_predicates; end
@@ -4989,44 +5273,37 @@ end
 
 ActiveRecord::Relation::WhereClause::ARRAY_WITH_EMPTY_STRING = T.let(T.unsafe(nil), Array)
 
-class ActiveRecord::Relation::WhereClauseFactory
-  def initialize(klass, predicate_builder); end
-
-  def build(opts, other); end
-
-  private
-
-  def klass; end
-  def predicate_builder; end
-end
-
 class ActiveRecord::Result
   include(::Enumerable)
 
   def initialize(columns, rows, column_types = T.unsafe(nil)); end
 
   def [](idx); end
+  def cancel; end
   def cast_values(type_overrides = T.unsafe(nil)); end
-  def collect!; end
+  def collect!(*args, &block); end
   def column_types; end
   def columns; end
   def each; end
   def empty?; end
-  def first; end
   def includes_column?(name); end
-  def last; end
+  def last(n = T.unsafe(nil)); end
   def length; end
-  def map!; end
+  def map!(*args, &block); end
+  def result; end
   def rows; end
   def to_a; end
   def to_ary; end
-  def to_hash; end
 
   private
 
   def column_type(name, type_overrides = T.unsafe(nil)); end
   def hash_rows; end
   def initialize_copy(other); end
+
+  class << self
+    def empty; end
+  end
 end
 
 class ActiveRecord::Rollback < ::ActiveRecord::ActiveRecordError
@@ -5035,14 +5312,10 @@ end
 class ActiveRecord::RuntimeRegistry
   extend(::ActiveSupport::PerThreadRegistry)
 
-  def connection_handler; end
-  def connection_handler=(_); end
   def sql_runtime; end
-  def sql_runtime=(_); end
+  def sql_runtime=(_arg0); end
 
   class << self
-    def connection_handler; end
-    def connection_handler=(x); end
     def sql_runtime; end
     def sql_runtime=(x); end
   end
@@ -5084,6 +5357,8 @@ end
 class ActiveRecord::SchemaDumper
   def initialize(connection, options = T.unsafe(nil)); end
 
+  def chk_ignore_pattern; end
+  def chk_ignore_pattern=(val); end
   def dump(stream); end
   def fk_ignore_pattern; end
   def fk_ignore_pattern=(val); end
@@ -5092,6 +5367,7 @@ class ActiveRecord::SchemaDumper
 
   private
 
+  def check_constraints_in_create(table, stream); end
   def define_params; end
   def extensions(stream); end
   def foreign_keys(table, stream); end
@@ -5107,11 +5383,13 @@ class ActiveRecord::SchemaDumper
   def remove_prefix_and_suffix(table); end
   def table(table, stream); end
   def table_name; end
-  def table_name=(_); end
+  def table_name=(_arg0); end
   def tables(stream); end
   def trailer(stream); end
 
   class << self
+    def chk_ignore_pattern; end
+    def chk_ignore_pattern=(val); end
     def dump(connection = T.unsafe(nil), stream = T.unsafe(nil), config = T.unsafe(nil)); end
     def fk_ignore_pattern; end
     def fk_ignore_pattern=(val); end
@@ -5128,10 +5406,8 @@ class ActiveRecord::SchemaMigration < ::ActiveRecord::Base
   def version; end
 
   class << self
-    def _internal?; end
     def _validators; end
     def all_versions; end
-    def attribute_type_decorations; end
     def create_table; end
     def defined_enums; end
     def drop_table; end
@@ -5158,6 +5434,8 @@ end
 module ActiveRecord::Scoping::ClassMethods
   def current_scope(skip_inherited_scope = T.unsafe(nil)); end
   def current_scope=(scope); end
+  def global_current_scope(skip_inherited_scope = T.unsafe(nil)); end
+  def global_current_scope=(scope); end
   def scope_attributes; end
   def scope_attributes?; end
 end
@@ -5170,18 +5448,27 @@ end
 
 module ActiveRecord::Scoping::Default::ClassMethods
   def before_remove_const; end
+  def default_scopes?(all_queries: T.unsafe(nil)); end
   def scope_attributes?; end
   def unscoped; end
 
   private
 
-  def build_default_scope(relation = T.unsafe(nil)); end
-  def default_scope(scope = T.unsafe(nil), &block); end
+  def build_default_scope(relation = T.unsafe(nil), all_queries: T.unsafe(nil)); end
+  def default_scope(scope = T.unsafe(nil), all_queries: T.unsafe(nil), &block); end
   def evaluate_default_scope; end
+  def execute_scope?(all_queries, default_scope_obj); end
   def ignore_default_scope=(ignore); end
   def ignore_default_scope?; end
 end
 
+class ActiveRecord::Scoping::DefaultScope
+  def initialize(scope, all_queries = T.unsafe(nil)); end
+
+  def all_queries; end
+  def scope; end
+end
+
 module ActiveRecord::Scoping::Named
   extend(::ActiveSupport::Concern)
 
@@ -5191,12 +5478,13 @@ end
 module ActiveRecord::Scoping::Named::ClassMethods
   def all; end
   def default_extensions; end
-  def default_scoped(scope = T.unsafe(nil)); end
+  def default_scoped(scope = T.unsafe(nil), all_queries: T.unsafe(nil)); end
   def scope(name, body, &block); end
   def scope_for_association(scope = T.unsafe(nil)); end
 
   private
 
+  def singleton_method_added(name); end
   def valid_scope_name?(name); end
 end
 
@@ -5245,10 +5533,32 @@ end
 class ActiveRecord::SerializationTypeMismatch < ::ActiveRecord::ActiveRecordError
 end
 
+module ActiveRecord::SignedId
+  extend(::ActiveSupport::Concern)
+
+  mixes_in_class_methods(::ActiveRecord::SignedId::ClassMethods)
+
+  def signed_id(expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
+end
+
+module ActiveRecord::SignedId::ClassMethods
+  def combine_signed_id_purposes(purpose); end
+  def find_signed(signed_id, purpose: T.unsafe(nil)); end
+  def find_signed!(signed_id, purpose: T.unsafe(nil)); end
+  def signed_id_verifier; end
+  def signed_id_verifier=(verifier); end
+end
+
+class ActiveRecord::SoleRecordExceeded < ::ActiveRecord::ActiveRecordError
+  def initialize(record = T.unsafe(nil)); end
+
+  def record; end
+end
+
 module ActiveRecord::SpawnMethods
   def except(*skips); end
-  def merge(other); end
-  def merge!(other); end
+  def merge(other, *rest); end
+  def merge!(other, *rest); end
   def only(*onlies); end
   def spawn; end
 
@@ -5305,8 +5615,9 @@ class ActiveRecord::StatementCache::PartialQueryCollector
 
   def <<(str); end
   def add_bind(obj); end
+  def add_binds(binds, proc_for_binds = T.unsafe(nil)); end
   def preparable; end
-  def preparable=(_); end
+  def preparable=(_arg0); end
   def value; end
 end
 
@@ -5392,8 +5703,8 @@ module ActiveRecord::Suppressor
 
   mixes_in_class_methods(::ActiveRecord::Suppressor::ClassMethods)
 
-  def save(**_); end
-  def save!(**_); end
+  def save(**_arg0); end
+  def save!(**_arg0); end
 end
 
 module ActiveRecord::Suppressor::ClassMethods
@@ -5409,33 +5720,27 @@ class ActiveRecord::SuppressorRegistry
 end
 
 class ActiveRecord::TableMetadata
-  def initialize(klass, arel_table, association = T.unsafe(nil), types = T.unsafe(nil)); end
+  def initialize(klass, arel_table, reflection = T.unsafe(nil)); end
 
   def aggregated_with?(aggregation_name); end
-  def arel_attribute(column_name); end
-  def associated_predicate_builder(table_name); end
+  def arel_table; end
   def associated_table(table_name); end
-  def associated_with?(association_name); end
-  def association_foreign_key(*args, &block); end
-  def association_foreign_type(*args, &block); end
-  def association_join_foreign_key(*args, &block); end
-  def association_join_primary_key(*args, &block); end
+  def associated_with?(table_name); end
   def has_column?(column_name); end
+  def join_foreign_key(*_arg0, &_arg1); end
+  def join_foreign_type(*_arg0, &_arg1); end
+  def join_primary_key(*_arg0, &_arg1); end
   def polymorphic_association?; end
+  def predicate_builder; end
+  def primary_key; end
   def reflect_on_aggregation(aggregation_name); end
-  def resolve_column_aliases(hash); end
+  def through_association?; end
   def type(column_name); end
 
-  protected
-
-  def predicate_builder; end
-
   private
 
-  def arel_table; end
-  def association; end
   def klass; end
-  def types; end
+  def reflection; end
 end
 
 class ActiveRecord::TableNotSpecified < ::ActiveRecord::ActiveRecordError
@@ -5448,7 +5753,7 @@ end
 module ActiveRecord::Tasks::DatabaseTasks
   extend(::ActiveRecord::Tasks::DatabaseTasks)
 
-  def cache_dump_filename(name, schema_cache_path: T.unsafe(nil)); end
+  def cache_dump_filename(db_config_name, schema_cache_path: T.unsafe(nil)); end
   def charset(configuration, *arguments); end
   def charset_current(env_name = T.unsafe(nil), db_name = T.unsafe(nil)); end
   def check_protected_environments!; end
@@ -5463,19 +5768,19 @@ module ActiveRecord::Tasks::DatabaseTasks
   def current_config(*args, &block); end
   def current_config=(*args, &block); end
   def database_configuration; end
-  def database_configuration=(_); end
+  def database_configuration=(_arg0); end
   def db_dir; end
-  def db_dir=(_); end
+  def db_dir=(_arg0); end
   def drop(configuration, *arguments); end
   def drop_all; end
   def drop_current(environment = T.unsafe(nil)); end
-  def dump_filename(name, format = T.unsafe(nil)); end
+  def dump_filename(db_config_name, format = T.unsafe(nil)); end
   def dump_schema(db_config, format = T.unsafe(nil)); end
   def dump_schema_cache(conn, filename); end
   def env; end
-  def env=(_); end
+  def env=(_arg0); end
   def fixtures_path; end
-  def fixtures_path=(_); end
+  def fixtures_path=(_arg0); end
   def for_each(databases); end
   def load_schema(db_config, format = T.unsafe(nil), file = T.unsafe(nil)); end
   def load_schema_current(format = T.unsafe(nil), file = T.unsafe(nil), environment = T.unsafe(nil)); end
@@ -5483,8 +5788,9 @@ module ActiveRecord::Tasks::DatabaseTasks
   def migrate; end
   def migrate_status; end
   def migrations_paths; end
-  def migrations_paths=(_); end
+  def migrations_paths=(_arg0); end
   def name; end
+  def prepare_all; end
   def purge(configuration); end
   def purge_all; end
   def purge_current(environment = T.unsafe(nil)); end
@@ -5492,12 +5798,12 @@ module ActiveRecord::Tasks::DatabaseTasks
   def reconstruct_from_schema(db_config, format = T.unsafe(nil), file = T.unsafe(nil)); end
   def register_task(pattern, task); end
   def root; end
-  def root=(_); end
-  def schema_file(format = T.unsafe(nil)); end
+  def root=(_arg0); end
+  def schema_file(*args, &block); end
   def schema_file_type(format = T.unsafe(nil)); end
   def schema_up_to_date?(configuration, format = T.unsafe(nil), file = T.unsafe(nil), environment = T.unsafe(nil), name = T.unsafe(nil)); end
   def seed_loader; end
-  def seed_loader=(_); end
+  def seed_loader=(_arg0); end
   def setup_initial_database_yaml; end
   def spec(*args, &block); end
   def structure_dump(configuration, *arguments); end
@@ -5508,12 +5814,15 @@ module ActiveRecord::Tasks::DatabaseTasks
   private
 
   def class_for_adapter(adapter); end
+  def configs_for(**options); end
   def database_adapter_for(db_config, *arguments); end
   def each_current_configuration(environment, name = T.unsafe(nil)); end
   def each_local_configuration; end
   def local_database?(db_config); end
   def resolve_configuration(configuration); end
   def schema_sha1(file); end
+  def structure_dump_flags_for(adapter); end
+  def structure_load_flags_for(adapter); end
   def truncate_tables(db_config); end
   def verbose?; end
 
@@ -5532,10 +5841,10 @@ class ActiveRecord::Tasks::MySQLDatabaseTasks
 
   def charset; end
   def collation; end
-  def connection(*args, &block); end
+  def connection(*_arg0, &_arg1); end
   def create; end
   def drop; end
-  def establish_connection(*args, &block); end
+  def establish_connection(*_arg0, &_arg1); end
   def purge; end
   def structure_dump(filename, extra_flags); end
   def structure_load(filename, extra_flags); end
@@ -5561,12 +5870,12 @@ class ActiveRecord::Tasks::PostgreSQLDatabaseTasks
   def initialize(db_config); end
 
   def charset; end
-  def clear_active_connections!(*args, &block); end
+  def clear_active_connections!(*_arg0, &_arg1); end
   def collation; end
-  def connection(*args, &block); end
+  def connection(*_arg0, &_arg1); end
   def create(master_established = T.unsafe(nil)); end
   def drop; end
-  def establish_connection(*args, &block); end
+  def establish_connection(*_arg0, &_arg1); end
   def purge; end
   def structure_dump(filename, extra_flags); end
   def structure_load(filename, extra_flags); end
@@ -5597,10 +5906,10 @@ class ActiveRecord::Tasks::SQLiteDatabaseTasks
   def initialize(db_config, root = T.unsafe(nil)); end
 
   def charset; end
-  def connection(*args, &block); end
+  def connection(*_arg0, &_arg1); end
   def create; end
   def drop; end
-  def establish_connection(*args, &block); end
+  def establish_connection(*_arg0, &_arg1); end
   def purge; end
   def structure_dump(filename, extra_flags); end
   def structure_load(filename, extra_flags); end
@@ -5671,7 +5980,7 @@ module ActiveRecord::Timestamp
   def _update_record; end
   def all_timestamp_attributes_in_model; end
   def clear_timestamp_attributes; end
-  def create_or_update(touch: T.unsafe(nil), **_); end
+  def create_or_update(touch: T.unsafe(nil), **_arg1); end
   def current_time_from_proper_timezone; end
   def initialize_dup(other); end
   def max_updated_column_timestamp; end
@@ -5703,7 +6012,7 @@ module ActiveRecord::TouchLater
 
   def belongs_to_touch_method; end
   def has_defer_touch_attrs?; end
-  def surreptitiously_touch(attrs); end
+  def surreptitiously_touch(attr_names); end
   def touch_deferred_attributes; end
 end
 
@@ -5722,9 +6031,9 @@ module ActiveRecord::Transactions
   def committed!(should_run_callbacks: T.unsafe(nil)); end
   def destroy; end
   def rolledback!(force_restore_state: T.unsafe(nil), should_run_callbacks: T.unsafe(nil)); end
-  def save(**_); end
-  def save!(**_); end
-  def touch(*_, **_); end
+  def save(**_arg0); end
+  def save!(**_arg0); end
+  def touch(*_arg0, **_arg1); end
   def transaction(**options, &block); end
   def trigger_transactional_callbacks?; end
   def with_transaction_returning_status; end
@@ -5734,13 +6043,11 @@ module ActiveRecord::Transactions
   def _committed_already_called; end
   def _trigger_destroy_callback; end
   def _trigger_update_callback; end
-  def add_to_transaction; end
+  def add_to_transaction(ensure_finalize = T.unsafe(nil)); end
   def clear_transaction_record_state; end
-  def force_clear_transaction_record_state; end
   def has_transactional_callbacks?; end
   def remember_transaction_record_state; end
   def restore_transaction_record_state(force_restore_state = T.unsafe(nil)); end
-  def sync_with_transaction_state; end
   def transaction_include_any_action?(actions); end
 end
 
@@ -5773,12 +6080,12 @@ end
 module ActiveRecord::Type
   class << self
     def adapter_name_from(model); end
-    def add_modifier(*args, &block); end
+    def add_modifier(*_arg0, &_arg1); end
     def default_value; end
     def lookup(*args, adapter: T.unsafe(nil), **kwargs); end
     def register(type_name, klass = T.unsafe(nil), **options, &block); end
     def registry; end
-    def registry=(_); end
+    def registry=(_arg0); end
 
     private
 
@@ -5842,6 +6149,8 @@ class ActiveRecord::Type::HashLookupTypeMap < ::ActiveRecord::Type::TypeMap
   def perform_fetch(type, *args, &block); end
 end
 
+ActiveRecord::Type::ImmutableString = ActiveModel::Type::ImmutableString
+
 ActiveRecord::Type::Integer = ActiveModel::Type::Integer
 
 module ActiveRecord::Type::Internal
@@ -5882,7 +6191,7 @@ class ActiveRecord::Type::Registration
 
   def conflicts_with?(other); end
   def has_adapter_conflict?(other); end
-  def matches_adapter?(adapter: T.unsafe(nil), **_); end
+  def matches_adapter?(adapter: T.unsafe(nil), **_arg1); end
   def same_priority_except_adapter?(other); end
 end
 
@@ -5917,6 +6226,10 @@ class ActiveRecord::Type::Time < ::ActiveModel::Type::Time
   include(::ActiveRecord::Type::Internal::Timezone)
 
   def serialize(value); end
+
+  private
+
+  def cast_value(value); end
 end
 
 class ActiveRecord::Type::Time::Value
@@ -5957,19 +6270,19 @@ class ActiveRecord::TypeCaster::Connection
 
   private
 
-  def connection(*args, &block); end
+  def connection(*_arg0, &_arg1); end
   def table_name; end
 end
 
 class ActiveRecord::TypeCaster::Map
-  def initialize(types); end
+  def initialize(klass); end
 
   def type_cast_for_database(attr_name, value); end
   def type_for_attribute(name); end
 
   private
 
-  def types; end
+  def klass; end
 end
 
 class ActiveRecord::TypeConflictError < ::StandardError
@@ -6083,17 +6396,18 @@ class ActiveRecord::Associations::JoinDependency::JoinPart
 
   def initialize(base_klass, children); end
 
+  def attribute_types(*_arg0, &_arg1); end
   def base_klass; end
   def children; end
-  def column_names(*args, &block); end
+  def column_names(*_arg0, &_arg1); end
   def each(&block); end
   def each_children(&block); end
   def extract_record(row, column_names_with_alias); end
-  def instantiate(row, aliases, &block); end
+  def instantiate(row, aliases, column_types = T.unsafe(nil), &block); end
   def match?(other); end
-  def primary_key(*args, &block); end
+  def primary_key(*_arg0, &_arg1); end
   def table; end
-  def table_name(*args, &block); end
+  def table_name(*_arg0, &_arg1); end
 end
 
 class ActiveRecord::ConcurrentMigrationError < ::ActiveRecord::MigrationError
@@ -6104,15 +6418,20 @@ ActiveRecord::ConcurrentMigrationError::DEFAULT_MESSAGE = T.let(T.unsafe(nil), S
 
 ActiveRecord::ConcurrentMigrationError::RELEASE_LOCK_FAILED_MESSAGE = T.let(T.unsafe(nil), String)
 
+module ActiveRecord::ConnectionAdapters::AbstractPool
+  def get_schema_cache(connection); end
+  def set_schema_cache(cache); end
+end
+
 class ActiveRecord::ConnectionAdapters::AddColumnDefinition < ::Struct
   def column; end
   def column=(_); end
 
   class << self
-    def [](*_); end
+    def [](*_arg0); end
     def inspect; end
     def members; end
-    def new(*_); end
+    def new(*_arg0); end
   end
 end
 
@@ -6131,6 +6450,22 @@ module ActiveRecord::ConnectionAdapters::ColumnMethods::ClassMethods
   def define_column_methods(*column_types); end
 end
 
+class ActiveRecord::ConnectionAdapters::CreateIndexDefinition < ::Struct
+  def algorithm; end
+  def algorithm=(_); end
+  def if_not_exists; end
+  def if_not_exists=(_); end
+  def index; end
+  def index=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
 module ActiveRecord::ConnectionAdapters::Deduplicable
   extend(::ActiveSupport::Concern)
 
@@ -6145,12 +6480,12 @@ module ActiveRecord::ConnectionAdapters::Deduplicable
 end
 
 module ActiveRecord::ConnectionAdapters::Deduplicable::ClassMethods
-  def new(*_, **_); end
+  def new(*_arg0, **_arg1); end
   def registry; end
 end
 
 class ActiveRecord::ConnectionAdapters::NullColumn < ::ActiveRecord::ConnectionAdapters::Column
-  def initialize(name, **_); end
+  def initialize(name, **_arg1); end
 end
 
 class ActiveRecord::ConnectionAdapters::PrimaryKeyDefinition < ::Struct
@@ -6158,10 +6493,10 @@ class ActiveRecord::ConnectionAdapters::PrimaryKeyDefinition < ::Struct
   def name=(_); end
 
   class << self
-    def [](*_); end
+    def [](*_arg0); end
     def inspect; end
     def members; end
-    def new(*_); end
+    def new(*_arg0); end
   end
 end
 
@@ -6175,7 +6510,7 @@ class ActiveRecord::ConnectionAdapters::SchemaCache
   def columns_hash(table_name); end
   def columns_hash?(table_name); end
   def connection; end
-  def connection=(_); end
+  def connection=(_arg0); end
   def data_source_exists?(name); end
   def data_sources(name); end
   def database_version; end
@@ -6216,24 +6551,34 @@ class ActiveRecord::ConnectionAdapters::SchemaCreation
 
   def action_sql(action, dependency); end
   def add_column_options!(sql, options); end
-  def add_table_options!(create_sql, options); end
+  def add_table_options!(create_sql, o); end
+  def check_constraint_in_create(table_name, expression, options); end
+  def check_constraint_options(*_arg0, &_arg1); end
   def column_options(o); end
   def foreign_key_in_create(from_table, to_table, options); end
-  def foreign_key_options(*args, &block); end
-  def options_include_default?(*args, &block); end
-  def quote_column_name(*args, &block); end
-  def quote_default_expression(*args, &block); end
-  def quote_table_name(*args, &block); end
-  def supports_foreign_keys?(*args, &block); end
-  def supports_indexes_in_create?(*args, &block); end
+  def foreign_key_options(*_arg0, &_arg1); end
+  def options_include_default?(*_arg0, &_arg1); end
+  def quote_column_name(*_arg0, &_arg1); end
+  def quote_default_expression(*_arg0, &_arg1); end
+  def quote_table_name(*_arg0, &_arg1); end
+  def quoted_columns(o); end
+  def quoted_columns_for_index(*_arg0, &_arg1); end
+  def supports_check_constraints?(*_arg0, &_arg1); end
+  def supports_foreign_keys?(*_arg0, &_arg1); end
+  def supports_index_using?; end
+  def supports_indexes_in_create?(*_arg0, &_arg1); end
+  def supports_partial_index?(*_arg0, &_arg1); end
   def table_modifier_in_create(o); end
-  def table_options(o); end
   def to_sql(sql); end
-  def type_to_sql(*args, &block); end
+  def type_to_sql(*_arg0, &_arg1); end
+  def visit_AddCheckConstraint(o); end
   def visit_AddColumnDefinition(o); end
   def visit_AddForeignKey(o); end
   def visit_AlterTable(o); end
+  def visit_CheckConstraintDefinition(o); end
   def visit_ColumnDefinition(o); end
+  def visit_CreateIndexDefinition(o); end
+  def visit_DropCheckConstraint(name); end
   def visit_DropForeignKey(name); end
   def visit_ForeignKeyDefinition(o); end
   def visit_PrimaryKeyDefinition(o); end
@@ -6286,7 +6631,7 @@ end
 class ActiveRecord::ConnectionAdapters::Transaction
   def initialize(connection, isolation: T.unsafe(nil), joinable: T.unsafe(nil), run_commit_callbacks: T.unsafe(nil)); end
 
-  def add_record(record); end
+  def add_record(record, ensure_finalize = T.unsafe(nil)); end
   def before_commit_records; end
   def closed?; end
   def commit_records; end
@@ -6301,6 +6646,11 @@ class ActiveRecord::ConnectionAdapters::Transaction
   def rollback_records; end
   def savepoint_name; end
   def state; end
+  def written; end
+  def written=(_arg0); end
+end
+
+class ActiveRecord::DestroyAssociationAsyncError < ::StandardError
 end
 
 class ActiveRecord::DuplicateMigrationNameError < ::ActiveRecord::MigrationError
@@ -6381,6 +6731,7 @@ class ActiveRecord::FixtureSet
     def instantiate_all_loaded_fixtures(object, load_instances = T.unsafe(nil)); end
     def instantiate_fixtures(object, fixture_set, load_instances = T.unsafe(nil)); end
     def reset_cache; end
+    def signed_global_id(fixture_set_name, label, column_type: T.unsafe(nil), **options); end
 
     private
 
@@ -6463,6 +6814,7 @@ class ActiveRecord::FixtureSet::TableRow::HasManyThroughProxy < ::ActiveRecord::
   def join_table; end
   def lhs_key; end
   def rhs_key; end
+  def timestamp_column_names; end
 end
 
 class ActiveRecord::FixtureSet::TableRow::ReflectionProxy
@@ -6494,9 +6846,8 @@ class ActiveRecord::IrreversibleMigration < ::ActiveRecord::MigrationError
 end
 
 class ActiveRecord::MigrationContext
-  def initialize(migrations_paths, schema_migration); end
+  def initialize(migrations_paths, schema_migration = T.unsafe(nil)); end
 
-  def any_migrations?; end
   def current_environment; end
   def current_version; end
   def down(target_version = T.unsafe(nil)); end
@@ -6529,19 +6880,19 @@ end
 class ActiveRecord::MigrationProxy < ::Struct
   def initialize(name, version, filename, scope); end
 
-  def announce(*args, &block); end
+  def announce(*_arg0, &_arg1); end
   def basename; end
-  def disable_ddl_transaction(*args, &block); end
+  def disable_ddl_transaction(*_arg0, &_arg1); end
   def filename; end
   def filename=(_); end
-  def migrate(*args, &block); end
+  def migrate(*_arg0, &_arg1); end
   def name; end
   def name=(_); end
   def scope; end
   def scope=(_); end
   def version; end
   def version=(_); end
-  def write(*args, &block); end
+  def write(*_arg0, &_arg1); end
 
   private
 
@@ -6549,10 +6900,10 @@ class ActiveRecord::MigrationProxy < ::Struct
   def migration; end
 
   class << self
-    def [](*_); end
+    def [](*_arg0); end
     def inspect; end
     def members; end
-    def new(*_); end
+    def new(*_arg0); end
   end
 end
 
@@ -6567,9 +6918,13 @@ class ActiveRecord::PendingMigrationError < ::ActiveRecord::MigrationError
   def initialize(message = T.unsafe(nil)); end
 
   def _actions; end
-  def _actions=(_); end
+  def _actions=(_arg0); end
   def _actions?; end
 
+  private
+
+  def detailed_migration_message; end
+
   class << self
     def _actions; end
     def _actions=(value); end
@@ -6622,27 +6977,6 @@ class Arel::Attributes::Attribute < ::Struct
   def type_caster; end
 end
 
-class Arel::Attributes::Boolean < ::Arel::Attributes::Attribute
-end
-
-class Arel::Attributes::Decimal < ::Arel::Attributes::Attribute
-end
-
-class Arel::Attributes::Float < ::Arel::Attributes::Attribute
-end
-
-class Arel::Attributes::Integer < ::Arel::Attributes::Attribute
-end
-
-class Arel::Attributes::String < ::Arel::Attributes::Attribute
-end
-
-class Arel::Attributes::Time < ::Arel::Attributes::Attribute
-end
-
-class Arel::Attributes::Undefined < ::Arel::Attributes::Attribute
-end
-
 module Arel::Collectors
 end
 
@@ -6651,6 +6985,7 @@ class Arel::Collectors::Bind
 
   def <<(str); end
   def add_bind(bind); end
+  def add_binds(binds, proc_for_binds = T.unsafe(nil)); end
   def value; end
 end
 
@@ -6659,8 +6994,9 @@ class Arel::Collectors::Composite
 
   def <<(str); end
   def add_bind(bind, &block); end
+  def add_binds(binds, proc_for_binds = T.unsafe(nil), &block); end
   def preparable; end
-  def preparable=(_); end
+  def preparable=(_arg0); end
   def value; end
 
   private
@@ -6677,11 +7013,12 @@ class Arel::Collectors::PlainString
 end
 
 class Arel::Collectors::SQLString < ::Arel::Collectors::PlainString
-  def initialize(*_); end
+  def initialize(*_arg0); end
 
   def add_bind(bind); end
+  def add_binds(binds, proc_for_binds = T.unsafe(nil), &block); end
   def preparable; end
-  def preparable=(_); end
+  def preparable=(_arg0); end
 end
 
 class Arel::Collectors::SubstituteBinds
@@ -6689,8 +7026,9 @@ class Arel::Collectors::SubstituteBinds
 
   def <<(str); end
   def add_bind(bind); end
+  def add_binds(binds, proc_for_binds = T.unsafe(nil)); end
   def preparable; end
-  def preparable=(_); end
+  def preparable=(_arg0); end
   def value; end
 
   private
@@ -6700,16 +7038,16 @@ class Arel::Collectors::SubstituteBinds
 end
 
 module Arel::Crud
-  def compile_delete; end
+  def compile_delete(key = T.unsafe(nil)); end
   def compile_insert(values); end
-  def compile_update(values, pk); end
+  def compile_update(values, key = T.unsafe(nil)); end
   def create_insert; end
 end
 
 class Arel::DeleteManager < ::Arel::TreeManager
   include(::Arel::TreeManager::StatementMethods)
 
-  def initialize; end
+  def initialize(table = T.unsafe(nil)); end
 
   def from(relation); end
 end
@@ -6740,7 +7078,7 @@ module Arel::FactoryMethods
 end
 
 class Arel::InsertManager < ::Arel::TreeManager
-  def initialize; end
+  def initialize(table = T.unsafe(nil)); end
 
   def columns; end
   def create_values(values); end
@@ -6815,9 +7153,9 @@ class Arel::Nodes::Binary < ::Arel::Nodes::NodeExpression
   def eql?(other); end
   def hash; end
   def left; end
-  def left=(_); end
+  def left=(_arg0); end
   def right; end
-  def right=(_); end
+  def right=(_arg0); end
 
   private
 
@@ -6866,11 +7204,11 @@ class Arel::Nodes::Case < ::Arel::Nodes::NodeExpression
 
   def ==(other); end
   def case; end
-  def case=(_); end
+  def case=(_arg0); end
   def conditions; end
-  def conditions=(_); end
+  def conditions=(_arg0); end
   def default; end
-  def default=(_); end
+  def default=(_arg0); end
   def else(expression); end
   def eql?(other); end
   def hash; end
@@ -6912,6 +7250,10 @@ class Arel::Nodes::Concat < ::Arel::Nodes::InfixOperation
   def initialize(left, right); end
 end
 
+class Arel::Nodes::Contains < ::Arel::Nodes::InfixOperation
+  def initialize(left, right); end
+end
+
 class Arel::Nodes::Count < ::Arel::Nodes::Function
   def initialize(expr, distinct = T.unsafe(nil), aliaz = T.unsafe(nil)); end
 end
@@ -6932,21 +7274,17 @@ class Arel::Nodes::DeleteStatement < ::Arel::Nodes::Node
   def eql?(other); end
   def hash; end
   def key; end
-  def key=(_); end
-  def left; end
-  def left=(_); end
+  def key=(_arg0); end
   def limit; end
-  def limit=(_); end
+  def limit=(_arg0); end
   def offset; end
-  def offset=(_); end
+  def offset=(_arg0); end
   def orders; end
-  def orders=(_); end
+  def orders=(_arg0); end
   def relation; end
-  def relation=(_); end
-  def right; end
-  def right=(_); end
+  def relation=(_arg0); end
   def wheres; end
-  def wheres=(_); end
+  def wheres=(_arg0); end
 
   private
 
@@ -6980,10 +7318,10 @@ class Arel::Nodes::Else < ::Arel::Nodes::Unary
 end
 
 class Arel::Nodes::Equality < ::Arel::Nodes::Binary
+  include(::Arel::Nodes::FetchAttribute)
+
   def equality?; end
-  def fetch_attribute; end
   def invert; end
-  def operator; end
 end
 
 class Arel::Nodes::Except < ::Arel::Nodes::Binary
@@ -6998,7 +7336,7 @@ class Arel::Nodes::Extract < ::Arel::Nodes::Unary
   def ==(other); end
   def eql?(other); end
   def field; end
-  def field=(_); end
+  def field=(_arg0); end
   def hash; end
 end
 
@@ -7026,22 +7364,26 @@ class Arel::Nodes::Function < ::Arel::Nodes::NodeExpression
 
   def ==(other); end
   def alias; end
-  def alias=(_); end
+  def alias=(_arg0); end
   def as(aliaz); end
   def distinct; end
-  def distinct=(_); end
+  def distinct=(_arg0); end
   def eql?(other); end
   def expressions; end
-  def expressions=(_); end
+  def expressions=(_arg0); end
   def hash; end
 end
 
 class Arel::Nodes::GreaterThan < ::Arel::Nodes::Binary
   include(::Arel::Nodes::FetchAttribute)
+
+  def invert; end
 end
 
 class Arel::Nodes::GreaterThanOrEqual < ::Arel::Nodes::Binary
   include(::Arel::Nodes::FetchAttribute)
+
+  def invert; end
 end
 
 class Arel::Nodes::Group < ::Arel::Nodes::Unary
@@ -7070,6 +7412,8 @@ class Arel::Nodes::HomogeneousIn < ::Arel::Nodes::Node
   def hash; end
   def invert; end
   def left; end
+  def proc_for_binds; end
+  def right; end
   def table_name; end
   def type; end
   def values; end
@@ -7079,7 +7423,10 @@ class Arel::Nodes::HomogeneousIn < ::Arel::Nodes::Node
   def ivars; end
 end
 
-class Arel::Nodes::In < ::Arel::Nodes::Equality
+class Arel::Nodes::In < ::Arel::Nodes::Binary
+  include(::Arel::Nodes::FetchAttribute)
+
+  def equality?; end
   def invert; end
 end
 
@@ -7093,19 +7440,19 @@ class Arel::Nodes::InnerJoin < ::Arel::Nodes::Join
 end
 
 class Arel::Nodes::InsertStatement < ::Arel::Nodes::Node
-  def initialize; end
+  def initialize(relation = T.unsafe(nil)); end
 
   def ==(other); end
   def columns; end
-  def columns=(_); end
+  def columns=(_arg0); end
   def eql?(other); end
   def hash; end
   def relation; end
-  def relation=(_); end
+  def relation=(_arg0); end
   def select; end
-  def select=(_); end
+  def select=(_arg0); end
   def values; end
-  def values=(_); end
+  def values=(_arg0); end
 
   private
 
@@ -7115,11 +7462,15 @@ end
 class Arel::Nodes::Intersect < ::Arel::Nodes::Binary
 end
 
-class Arel::Nodes::IsDistinctFrom < ::Arel::Nodes::Equality
+class Arel::Nodes::IsDistinctFrom < ::Arel::Nodes::Binary
+  include(::Arel::Nodes::FetchAttribute)
+
   def invert; end
 end
 
-class Arel::Nodes::IsNotDistinctFrom < ::Arel::Nodes::Equality
+class Arel::Nodes::IsNotDistinctFrom < ::Arel::Nodes::Binary
+  include(::Arel::Nodes::FetchAttribute)
+
   def invert; end
 end
 
@@ -7135,12 +7486,19 @@ end
 class Arel::Nodes::Lateral < ::Arel::Nodes::Unary
 end
 
+class Arel::Nodes::LeadingJoin < ::Arel::Nodes::InnerJoin
+end
+
 class Arel::Nodes::LessThan < ::Arel::Nodes::Binary
   include(::Arel::Nodes::FetchAttribute)
+
+  def invert; end
 end
 
 class Arel::Nodes::LessThanOrEqual < ::Arel::Nodes::Binary
   include(::Arel::Nodes::FetchAttribute)
+
+  def invert; end
 end
 
 class Arel::Nodes::Limit < ::Arel::Nodes::Unary
@@ -7153,7 +7511,7 @@ class Arel::Nodes::Matches < ::Arel::Nodes::Binary
   def initialize(left, right, escape = T.unsafe(nil), case_sensitive = T.unsafe(nil)); end
 
   def case_sensitive; end
-  def case_sensitive=(_); end
+  def case_sensitive=(_arg0); end
   def escape; end
 end
 
@@ -7174,7 +7532,7 @@ class Arel::Nodes::NamedFunction < ::Arel::Nodes::Function
   def eql?(other); end
   def hash; end
   def name; end
-  def name=(_); end
+  def name=(_arg0); end
 end
 
 class Arel::Nodes::NamedWindow < ::Arel::Nodes::Window
@@ -7184,7 +7542,7 @@ class Arel::Nodes::NamedWindow < ::Arel::Nodes::Window
   def eql?(other); end
   def hash; end
   def name; end
-  def name=(_); end
+  def name=(_arg0); end
 
   private
 
@@ -7216,19 +7574,25 @@ end
 
 class Arel::Nodes::NotEqual < ::Arel::Nodes::Binary
   include(::Arel::Nodes::FetchAttribute)
+
+  def invert; end
 end
 
 class Arel::Nodes::NotIn < ::Arel::Nodes::Binary
   include(::Arel::Nodes::FetchAttribute)
+
+  def invert; end
 end
 
 class Arel::Nodes::NotRegexp < ::Arel::Nodes::Regexp
 end
 
 class Arel::Nodes::NullsFirst < ::Arel::Nodes::Ordering
+  def reverse; end
 end
 
 class Arel::Nodes::NullsLast < ::Arel::Nodes::Ordering
+  def reverse; end
 end
 
 class Arel::Nodes::Offset < ::Arel::Nodes::Unary
@@ -7258,6 +7622,10 @@ class Arel::Nodes::Over < ::Arel::Nodes::Binary
   def operator; end
 end
 
+class Arel::Nodes::Overlaps < ::Arel::Nodes::InfixOperation
+  def initialize(left, right); end
+end
+
 class Arel::Nodes::Preceding < ::Arel::Nodes::Unary
   def initialize(expr = T.unsafe(nil)); end
 end
@@ -7277,7 +7645,7 @@ class Arel::Nodes::Regexp < ::Arel::Nodes::Binary
   def initialize(left, right, case_sensitive = T.unsafe(nil)); end
 
   def case_sensitive; end
-  def case_sensitive=(_); end
+  def case_sensitive=(_arg0); end
 end
 
 class Arel::Nodes::RightOuterJoin < ::Arel::Nodes::Join
@@ -7291,33 +7659,33 @@ class Arel::Nodes::Rows < ::Arel::Nodes::Unary
 end
 
 class Arel::Nodes::SelectCore < ::Arel::Nodes::Node
-  def initialize; end
+  def initialize(relation = T.unsafe(nil)); end
 
   def ==(other); end
   def comment; end
-  def comment=(_); end
+  def comment=(_arg0); end
   def eql?(other); end
   def from; end
   def from=(value); end
   def froms; end
   def froms=(value); end
   def groups; end
-  def groups=(_); end
+  def groups=(_arg0); end
   def hash; end
   def havings; end
-  def havings=(_); end
+  def havings=(_arg0); end
   def optimizer_hints; end
-  def optimizer_hints=(_); end
+  def optimizer_hints=(_arg0); end
   def projections; end
-  def projections=(_); end
+  def projections=(_arg0); end
   def set_quantifier; end
-  def set_quantifier=(_); end
+  def set_quantifier=(_arg0); end
   def source; end
-  def source=(_); end
+  def source=(_arg0); end
   def wheres; end
-  def wheres=(_); end
+  def wheres=(_arg0); end
   def windows; end
-  def windows=(_); end
+  def windows=(_arg0); end
 
   private
 
@@ -7325,22 +7693,22 @@ class Arel::Nodes::SelectCore < ::Arel::Nodes::Node
 end
 
 class Arel::Nodes::SelectStatement < ::Arel::Nodes::NodeExpression
-  def initialize(cores = T.unsafe(nil)); end
+  def initialize(relation = T.unsafe(nil)); end
 
   def ==(other); end
   def cores; end
   def eql?(other); end
   def hash; end
   def limit; end
-  def limit=(_); end
+  def limit=(_arg0); end
   def lock; end
-  def lock=(_); end
+  def lock=(_arg0); end
   def offset; end
-  def offset=(_); end
+  def offset=(_arg0); end
   def orders; end
-  def orders=(_); end
+  def orders=(_arg0); end
   def with; end
-  def with=(_); end
+  def with=(_arg0); end
 
   private
 
@@ -7375,7 +7743,7 @@ class Arel::Nodes::TableAlias < ::Arel::Nodes::Binary
   def relation; end
   def table_alias; end
   def table_name; end
-  def type_cast_for_database(*args); end
+  def type_cast_for_database(attr_name, value); end
   def type_for_attribute(name); end
 end
 
@@ -7391,7 +7759,7 @@ class Arel::Nodes::Unary < ::Arel::Nodes::NodeExpression
   def ==(other); end
   def eql?(other); end
   def expr; end
-  def expr=(_); end
+  def expr=(_arg0); end
   def hash; end
   def value; end
 end
@@ -7410,32 +7778,32 @@ end
 
 class Arel::Nodes::UnqualifiedColumn < ::Arel::Nodes::Unary
   def attribute; end
-  def attribute=(_); end
+  def attribute=(_arg0); end
   def column; end
   def name; end
   def relation; end
 end
 
 class Arel::Nodes::UpdateStatement < ::Arel::Nodes::Node
-  def initialize; end
+  def initialize(relation = T.unsafe(nil)); end
 
   def ==(other); end
   def eql?(other); end
   def hash; end
   def key; end
-  def key=(_); end
+  def key=(_arg0); end
   def limit; end
-  def limit=(_); end
+  def limit=(_arg0); end
   def offset; end
-  def offset=(_); end
+  def offset=(_arg0); end
   def orders; end
-  def orders=(_); end
+  def orders=(_arg0); end
   def relation; end
-  def relation=(_); end
+  def relation=(_arg0); end
   def values; end
-  def values=(_); end
+  def values=(_arg0); end
   def wheres; end
-  def wheres=(_); end
+  def wheres=(_arg0); end
 
   private
 
@@ -7456,14 +7824,14 @@ class Arel::Nodes::Window < ::Arel::Nodes::Node
   def eql?(other); end
   def frame(expr); end
   def framing; end
-  def framing=(_); end
+  def framing=(_arg0); end
   def hash; end
   def order(*expr); end
   def orders; end
-  def orders=(_); end
+  def orders=(_arg0); end
   def partition(*expr); end
   def partitions; end
-  def partitions=(_); end
+  def partitions=(_arg0); end
   def range(expr = T.unsafe(nil)); end
   def rows(expr = T.unsafe(nil)); end
 
@@ -7487,6 +7855,7 @@ end
 module Arel::Predications
   def between(other); end
   def concat(other); end
+  def contains(other); end
   def does_not_match(other, escape = T.unsafe(nil), case_sensitive = T.unsafe(nil)); end
   def does_not_match_all(others, escape = T.unsafe(nil)); end
   def does_not_match_any(others, escape = T.unsafe(nil)); end
@@ -7522,6 +7891,8 @@ module Arel::Predications
   def not_in(other); end
   def not_in_all(others); end
   def not_in_any(others); end
+  def overlaps(other); end
+  def quoted_array(others); end
   def when(right); end
 
   private
@@ -7530,7 +7901,6 @@ module Arel::Predications
   def grouping_any(method_id, others, *extras); end
   def infinity?(value); end
   def open_ended?(value); end
-  def quoted_array(others); end
   def quoted_node(other); end
   def unboundable?(value); end
 end
@@ -7575,6 +7945,7 @@ class Arel::SelectManager < ::Arel::TreeManager
   def take(limit); end
   def taken; end
   def union(operation, other = T.unsafe(nil)); end
+  def where(expr); end
   def where_sql(engine = T.unsafe(nil)); end
   def window(name); end
   def with(*subqueries); end
@@ -7588,13 +7959,13 @@ end
 Arel::SelectManager::STRING_OR_SYMBOL_CLASS = T.let(T.unsafe(nil), Array)
 
 class Arel::Table
-  include(::Arel::Crud)
   include(::Arel::FactoryMethods)
+  include(::Arel::AliasPredication)
 
-  def initialize(name, as: T.unsafe(nil), type_caster: T.unsafe(nil)); end
+  def initialize(name, as: T.unsafe(nil), klass: T.unsafe(nil), type_caster: T.unsafe(nil)); end
 
   def ==(other); end
-  def [](name); end
+  def [](name, table = T.unsafe(nil)); end
   def able_to_type_cast?; end
   def alias(name = T.unsafe(nil)); end
   def eql?(other); end
@@ -7604,16 +7975,16 @@ class Arel::Table
   def having(expr); end
   def join(relation, klass = T.unsafe(nil)); end
   def name; end
-  def name=(_); end
+  def name=(_arg0); end
   def order(*expr); end
   def outer_join(relation); end
   def project(*things); end
   def skip(amount); end
   def table_alias; end
-  def table_alias=(_); end
+  def table_alias=(_arg0); end
   def table_name; end
   def take(amount); end
-  def type_cast_for_database(attribute_name, value); end
+  def type_cast_for_database(attr_name, value); end
   def type_for_attribute(name); end
   def where(condition); end
 
@@ -7623,19 +7994,16 @@ class Arel::Table
 
   class << self
     def engine; end
-    def engine=(_); end
+    def engine=(_arg0); end
   end
 end
 
 class Arel::TreeManager
   include(::Arel::FactoryMethods)
 
-  def initialize; end
-
   def ast; end
   def to_dot; end
   def to_sql(engine = T.unsafe(nil)); end
-  def where(expr); end
 
   private
 
@@ -7655,7 +8023,7 @@ end
 class Arel::UpdateManager < ::Arel::TreeManager
   include(::Arel::TreeManager::StatementMethods)
 
-  def initialize; end
+  def initialize(table = T.unsafe(nil)); end
 
   def set(values); end
   def table(table); end
@@ -7684,13 +8052,7 @@ class Arel::Visitors::Dot < ::Arel::Visitors::Visitor
   def unary(o); end
   def visit(o); end
   def visit_ActiveModel_Attribute(o); end
-  def visit_Arel_Attribute(o); end
   def visit_Arel_Attributes_Attribute(o); end
-  def visit_Arel_Attributes_Boolean(o); end
-  def visit_Arel_Attributes_Float(o); end
-  def visit_Arel_Attributes_Integer(o); end
-  def visit_Arel_Attributes_String(o); end
-  def visit_Arel_Attributes_Time(o); end
   def visit_Arel_Nodes_And(o); end
   def visit_Arel_Nodes_As(o); end
   def visit_Arel_Nodes_Assignment(o); end
@@ -7783,11 +8145,11 @@ class Arel::Visitors::Dot::Node
   def initialize(name, id, fields = T.unsafe(nil)); end
 
   def fields; end
-  def fields=(_); end
+  def fields=(_arg0); end
   def id; end
-  def id=(_); end
+  def id=(_arg0); end
   def name; end
-  def name=(_); end
+  def name=(_arg0); end
 end
 
 class Arel::Visitors::MySQL < ::Arel::Visitors::ToSql
@@ -7812,9 +8174,9 @@ class Arel::Visitors::PostgreSQL < ::Arel::Visitors::ToSql
 
   private
 
+  def bind_block; end
   def grouping_array_or_grouping_element(o, collector); end
   def grouping_parentheses(o, collector); end
-  def visit_Arel_Nodes_BindParam(o, collector); end
   def visit_Arel_Nodes_Cube(o, collector); end
   def visit_Arel_Nodes_DistinctOn(o, collector); end
   def visit_Arel_Nodes_DoesNotMatch(o, collector); end
@@ -7851,7 +8213,9 @@ class Arel::Visitors::ToSql < ::Arel::Visitors::Visitor
   private
 
   def aggregate(name, o, collector); end
+  def bind_block; end
   def build_subselect(key, o); end
+  def collect_ctes(children, collector); end
   def collect_nodes_for(nodes, collector, spacer, connector = T.unsafe(nil)); end
   def collect_optimizer_hints(o, collector); end
   def has_join_sources?(o); end
@@ -7869,10 +8233,10 @@ class Arel::Visitors::ToSql < ::Arel::Visitors::Visitor
   def sanitize_as_sql_comment(value); end
   def unboundable?(value); end
   def unsupported(o, collector); end
+  def visit_ActiveModel_Attribute(o, collector); end
   def visit_ActiveSupport_Multibyte_Chars(o, collector); end
   def visit_ActiveSupport_StringInquirer(o, collector); end
   def visit_Arel_Attributes_Attribute(o, collector); end
-  def visit_Arel_Nodes_Addition(o, collector); end
   def visit_Arel_Nodes_And(o, collector); end
   def visit_Arel_Nodes_As(o, collector); end
   def visit_Arel_Nodes_Ascending(o, collector); end
@@ -7890,7 +8254,6 @@ class Arel::Visitors::ToSql < ::Arel::Visitors::Visitor
   def visit_Arel_Nodes_Descending(o, collector); end
   def visit_Arel_Nodes_Distinct(o, collector); end
   def visit_Arel_Nodes_DistinctOn(o, collector); end
-  def visit_Arel_Nodes_Division(o, collector); end
   def visit_Arel_Nodes_DoesNotMatch(o, collector); end
   def visit_Arel_Nodes_Else(o, collector); end
   def visit_Arel_Nodes_Equality(o, collector); end
@@ -7920,7 +8283,6 @@ class Arel::Visitors::ToSql < ::Arel::Visitors::Visitor
   def visit_Arel_Nodes_Matches(o, collector); end
   def visit_Arel_Nodes_Max(o, collector); end
   def visit_Arel_Nodes_Min(o, collector); end
-  def visit_Arel_Nodes_Multiplication(o, collector); end
   def visit_Arel_Nodes_NamedFunction(o, collector); end
   def visit_Arel_Nodes_NamedWindow(o, collector); end
   def visit_Arel_Nodes_Not(o, collector); end
@@ -7944,7 +8306,6 @@ class Arel::Visitors::ToSql < ::Arel::Visitors::Visitor
   def visit_Arel_Nodes_SelectStatement(o, collector); end
   def visit_Arel_Nodes_SqlLiteral(o, collector); end
   def visit_Arel_Nodes_StringJoin(o, collector); end
-  def visit_Arel_Nodes_Subtraction(o, collector); end
   def visit_Arel_Nodes_Sum(o, collector); end
   def visit_Arel_Nodes_TableAlias(o, collector); end
   def visit_Arel_Nodes_True(o, collector); end
@@ -7997,15 +8358,6 @@ class Arel::Visitors::Visitor
   end
 end
 
-class Arel::Visitors::WhereSql < ::Arel::Visitors::ToSql
-  def initialize(inner_visitor, *args, &block); end
-
-
-  private
-
-  def visit_Arel_Nodes_SelectCore(o, collector); end
-end
-
 module Arel::WindowPredications
   def over(expr = T.unsafe(nil)); end
 end